codetool-shell 0.1.1__py3-none-win_arm64.whl

codetool_shell/filters/opaque_payload/summary.py

@@ -0,0 +1,61 @@
+"""Summary line formatting for opaque payloads."""
+
+from __future__ import annotations
+
+
+def byte_len(text: str) -> int:
+    """Return UTF-8 byte length for summary accounting."""
+
+    return len(text.encode("utf-8"))
+
+
+def format_base64_summary(*, line_count: int, byte_count: int) -> str:
+    return (
+        "[opaque payload omitted: "
+        f"kind=base64 lines={line_count} bytes={byte_count}]"
+    )
+
+
+def format_pem_summary(*, label: str, line_count: int, byte_count: int) -> str:
+    return (
+        "[opaque payload omitted: "
+        f"kind=pem label={_quote(label)} lines={line_count} bytes={byte_count}]"
+    )
+
+
+def format_data_url_summary(*, mime: str, encoding: str, byte_count: int) -> str:
+    return (
+        "[opaque payload omitted: "
+        f"kind=data-url mime={mime} encoding={encoding} bytes={byte_count}]"
+    )
+
+
+def format_html_summary(*, byte_count: int, title: str | None) -> str:
+    if title:
+        return (
+            "[opaque payload omitted: "
+            f"kind=html bytes={byte_count} title={_quote(title)}]"
+        )
+    return f"[opaque payload omitted: kind=html bytes={byte_count}]"
+
+
+def format_json_summary(*, kind: str, keys: list[str], byte_count: int) -> str:
+    return (
+        "[opaque payload omitted: "
+        f"kind={kind} keys={','.join(keys)} bytes={byte_count}]"
+    )
+
+
+def format_minified_js_summary(*, byte_count: int) -> str:
+    return f"[opaque payload omitted: kind=minified-js bytes={byte_count}]"
+
+
+def with_final_newline(line: str, final_newline: bool) -> str:
+    if final_newline:
+        return f"{line}\n"
+    return line
+
+
+def _quote(value: str) -> str:
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'

codetool_shell/filters/package_manager/__init__.py

@@ -0,0 +1,7 @@
+"""Package-manager log shellion filter."""
+
+from __future__ import annotations
+
+from .reducer import compress_package_manager_output
+
+__all__ = ["compress_package_manager_output"]

codetool_shell/filters/package_manager/detector.py

@@ -0,0 +1,220 @@
+"""Detect conservative package-manager log shapes."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from .summary import has_compiler_diagnostics
+
+
+@dataclass(frozen=True)
+class PackageManagerLog:
+    """Detected package-manager log metadata."""
+
+    manager: str
+    failed: bool
+    warning: bool
+
+
+_MANAGER_PATTERNS: tuple[tuple[str, tuple[re.Pattern[str], ...]], ...] = (
+    (
+        "uv/pip",
+        (
+            re.compile(r"\b(?:collecting|using cached|successfully installed)\b", re.I),
+            re.compile(r"\b(?:resolved|prepared|installed|uninstalled) \d+ packages?\b", re.I),
+            re.compile(
+                r"\b(?:uv sync|uv\.lock|lockfile|lock file|--frozen|--locked|"
+                r"no solution found|virtual environment at|audited \d+ packages?)\b",
+                re.I,
+            ),
+            re.compile(r"^\s*[+\-~]\s+[A-Za-z0-9_.-]+==", re.I),
+        ),
+    ),
+    (
+        "poetry",
+        (
+            re.compile(r"\b(?:poetry\.lock|poetry install|poetry update)\b", re.I),
+            re.compile(r"^\s*Installing dependencies from lock file", re.I),
+            re.compile(r"^\s*Package operations:\s+\d+\s+installs?", re.I),
+            re.compile(r"^\s*-\s+(?:Installing|Updating|Upgrading|Downgrading|Removing)\s+[-A-Za-z0-9_.]+\s+\(", re.I),
+            re.compile(r"\b(?:version solving failed|SolverProblemError)\b", re.I),
+        ),
+    ),
+    (
+        "npm",
+        (
+            re.compile(r"^\s*npm\s+(?:warn|err!|notice|http|timing|verb|sill)\b", re.I),
+            re.compile(r"\b(?:added|removed|changed|updated) \d+ packages?\b", re.I),
+            re.compile(r"\b(?:audited \d+ packages?|found \d+ vulnerabilities?|npm audit fix)\b", re.I),
+        ),
+    ),
+    (
+        "pnpm",
+        (
+            re.compile(r"^\s*(?:Progress:\s+resolved|Packages:\s*[+\-]\d+|Lockfile is up to date)", re.I),
+            re.compile(r"\b(?:pnpm-lock\.yaml|ERR_PNPM_|WARN_PNPM_|frozen-lockfile|pnpm audit)\b", re.I),
+            re.compile(r"^\s*(?:dependencies|devDependencies|optionalDependencies|peerDependencies):\s*$", re.I),
+            re.compile(r"^\s*[+\-]\s+[@A-Za-z0-9_.-][@A-Za-z0-9_.+\-/]*\s+\d", re.I),
+        ),
+    ),
+    (
+        "yarn",
+        (
+            re.compile(r"^\s*yarn install v?\d", re.I),
+            re.compile(r"^\s*\[\d+/\d+\]\s+(?:Resolving|Fetching|Linking|Building)", re.I),
+            re.compile(r"^\s*(?:success Saved lockfile|success Saved \d+|Done in [\d.]+s|info Direct dependencies|info All dependencies)", re.I),
+            re.compile(r"^\s*➤\s+YN\d{4}:", re.I),
+            re.compile(r"\b(?:yarn\.lock|peer dependency|unmet peer|immutable install|lockfile would have been modified)\b", re.I),
+        ),
+    ),
+    (
+        "bun",
+        (
+            re.compile(r"\bbun install v?\d", re.I),
+            re.compile(r"\b(?:saved lockfile|\d+ packages? installed)\b", re.I),
+            re.compile(r"^\s*\+\s+[@A-Za-z0-9_.-]+@", re.I),
+        ),
+    ),
+    (
+        "composer",
+        (
+            re.compile(r"\b(?:composer\.json|composer\.lock|composer audit|security vulnerability advisories)\b", re.I),
+            re.compile(r"^\s*(?:Loading composer repositories|Installing dependencies from lock file|Generating autoload files)", re.I),
+            re.compile(r"^\s*(?:Package operations|Lock file operations):", re.I),
+            re.compile(r"^\s*-\s+(?:Locking|Installing|Updating|Upgrading|Removing|Downloading)\s+[-A-Za-z0-9_.]+/[-A-Za-z0-9_.]+\s+\(", re.I),
+        ),
+    ),
+    (
+        "bundler",
+        (
+            re.compile(r"\b(?:Bundle complete|Bundle updated|Gemfile\.lock|Bundler could not|rubygems\.org)\b", re.I),
+            re.compile(r"^\s*Fetching gem metadata", re.I),
+            re.compile(r"^\s*(?:Using|Fetching|Installing)\s+[-A-Za-z0-9_.]+\s+(?:\(|v?\d)", re.I),
+            re.compile(r"\bgems? now installed\b", re.I),
+        ),
+    ),
+    (
+        "homebrew",
+        (
+            re.compile(r"^\s*==>\s+(?:Fetching|Downloading|Pouring|Installing|Caveats|Summary|Homebrew|Autoremoving)", re.I),
+            re.compile(r"\b(?:/opt/homebrew/Cellar|/usr/local/Cellar|Homebrew/homebrew|brew install|bottle\.tar\.gz)\b", re.I),
+            re.compile(r"^\s*🍺"),
+        ),
+    ),
+    (
+        "cargo",
+        (
+            re.compile(r"\b(?:updating crates\.io index|downloading crates)\b", re.I),
+            re.compile(r"\b(?:locking \d+ packages?|installed package|installing [A-Za-z0-9_.-]+ v?\d)\b", re.I),
+            re.compile(r"^\s*(?:adding|removing|updating|downgrading)\s+[A-Za-z0-9_.-]+\s+v?\d", re.I),
+        ),
+    ),
+    (
+        "pre-commit",
+        (
+            re.compile(r"^\s*pre-commit installed at\b", re.I),
+            re.compile(r"^\s*\[INFO\]\s+(?:Initializing|Installing|Updating) environment for\b", re.I),
+            re.compile(r"\b(?:\.cache/pre-commit|pre-commit\.log)\b", re.I),
+            re.compile(r"^\s*\[ERROR\].*(?:pre-commit|unexpected error|CalledProcessError|log at)", re.I),
+        ),
+    ),
+)
+_FAILURE_RE = re.compile(
+    r"\b(?:error|err!|err_[a-z0-9_]+|failed|failure|fatal|no solution|conflict|"
+    r"could not|version solving failed|SolverProblemError)\b|^×\s|YN(?:0001|0028)",
+    re.I,
+)
+_WARNING_RE = re.compile(
+    r"\b(?:warn|warning|vulnerab|security advisory|advisory|advisories|peer dependency|unmet peer)\b|"
+    r"YN(?:0002|0060|0086)",
+    re.I,
+)
+
+
+def detect_package_manager_log(lines: list[str]) -> PackageManagerLog | None:
+    """Return a strong package-manager signal, or ``None``."""
+
+    nonblank = [line for line in lines if line.strip()]
+    if len(nonblank) < 2:
+        return None
+
+    text = "\n".join(nonblank)
+    if has_compiler_diagnostics(text):
+        return None
+    if _has_pre_commit_hook_results(nonblank):
+        return None
+
+    manager_scores: dict[str, int] = {}
+    for manager, patterns in _MANAGER_PATTERNS:
+        score = sum(1 for line in nonblank for pattern in patterns if pattern.search(line))
+        if score:
+            manager_scores[manager] = score
+
+    if "pnpm" in manager_scores and not _has_pnpm_anchor(nonblank):
+        del manager_scores["pnpm"]
+    if "homebrew" in manager_scores and not _has_homebrew_anchor(nonblank):
+        del manager_scores["homebrew"]
+    if "bundler" in manager_scores and not _has_bundler_anchor(nonblank):
+        del manager_scores["bundler"]
+
+    if not manager_scores:
+        return None
+
+    total_score = sum(manager_scores.values())
+    has_strong_multiline_signal = total_score >= 2 and len(nonblank) >= 4
+    has_failure_signal = total_score >= 1 and len(nonblank) >= 4 and _FAILURE_RE.search(text)
+    if not (has_strong_multiline_signal or has_failure_signal):
+        return None
+
+    manager = max(manager_scores.items(), key=lambda item: (item[1], item[0]))[0]
+    return PackageManagerLog(
+        manager=manager,
+        failed=_FAILURE_RE.search(text) is not None,
+        warning=_WARNING_RE.search(text) is not None,
+    )
+
+
+def _has_pre_commit_hook_results(lines: list[str]) -> bool:
+    return any(
+        re.search(r"\.{3,}(?:Passed|Failed|Skipped)$", line.strip()) for line in lines
+    )
+
+
+def _has_pnpm_anchor(lines: list[str]) -> bool:
+    text = "\n".join(lines)
+    return re.search(
+        r"\b(?:pnpm-lock\.yaml|ERR_PNPM_|WARN_PNPM_|frozen-lockfile|pnpm audit|pnpm install)\b",
+        text,
+        re.I,
+    ) is not None or any(
+        re.search(
+            r"^\s*(?:Progress:\s+resolved|Packages:\s*[+\-]\d+|Lockfile is up to date)",
+            line,
+            re.I,
+        )
+        for line in lines
+    )
+
+
+def _has_homebrew_anchor(lines: list[str]) -> bool:
+    return any(
+        re.search(
+            r"\b(?:Homebrew|brew\b|Cellar|bottle|formula|cask|tap)\b|"
+            r"(?:/opt/homebrew|/usr/local/Homebrew|/usr/local/Cellar)\b|^\s*🍺",
+            line,
+            re.I,
+        )
+        for line in lines
+    )
+
+
+def _has_bundler_anchor(lines: list[str]) -> bool:
+    return any(
+        re.search(
+            r"\b(?:Gemfile\.lock|bundler|rubygems\.org|Bundle complete|Bundle updated|gems? now installed)\b",
+            line,
+            re.I,
+        )
+        for line in lines
+    )

codetool_shell/filters/package_manager/reducer.py

@@ -0,0 +1,110 @@
+"""Conservative reducer for package-manager logs."""
+
+from __future__ import annotations
+
+from ..text import join_preserving_final_newline, score, split_preserving_final_newline
+from .detector import PackageManagerLog, detect_package_manager_log
+from .summary import (
+    is_important_line,
+    is_package_change_line,
+    is_progress_line,
+    normalize_selected_line,
+)
+
+_PACKAGE_HEAD = 3
+_PACKAGE_TAIL = 2
+
+
+def compress_package_manager_output(text: str) -> str:
+    """Compress conservative package install/update logs."""
+
+    lines, final_newline = split_preserving_final_newline(text)
+    signal = detect_package_manager_log(lines)
+    if signal is None:
+        return text
+
+    candidate_lines = _reduce_lines(lines, signal)
+    if len(candidate_lines) < 2:
+        return text
+
+    candidate = join_preserving_final_newline(candidate_lines, final_newline)
+    if score(candidate) < score(text):
+        return candidate
+    return text
+
+
+def _reduce_lines(lines: list[str], signal: PackageManagerLog) -> list[str]:
+    outcome = "failure" if signal.failed else "warning" if signal.warning else "success"
+    selected = [f"package manager: {signal.manager} {outcome}"]
+    progress_omitted = 0
+    package_run: list[str] = []
+
+    def flush_progress() -> None:
+        nonlocal progress_omitted
+        if progress_omitted:
+            plural = "" if progress_omitted == 1 else "s"
+            selected.append(
+                f"… {progress_omitted} package-manager progress line{plural} omitted"
+            )
+            progress_omitted = 0
+
+    def flush_package_run() -> None:
+        if not package_run:
+            return
+        flush_progress()
+        selected.extend(_format_package_run(package_run))
+        package_run.clear()
+
+    for raw_line in lines:
+        line = raw_line.strip()
+        if not line:
+            continue
+
+        if is_package_change_line(line):
+            package_run.append(normalize_selected_line(line))
+            continue
+
+        flush_package_run()
+
+        if is_important_line(line):
+            flush_progress()
+            selected.append(normalize_selected_line(line))
+            continue
+
+        if is_progress_line(line):
+            progress_omitted += 1
+            continue
+
+        if signal.failed:
+            flush_progress()
+            selected.append(normalize_selected_line(line))
+        else:
+            progress_omitted += 1
+
+    flush_package_run()
+    flush_progress()
+    return _drop_adjacent_duplicates(selected)
+
+
+def _format_package_run(lines: list[str]) -> list[str]:
+    if len(lines) <= _PACKAGE_HEAD + _PACKAGE_TAIL + 1:
+        return list(lines)
+
+    omitted = len(lines) - _PACKAGE_HEAD - _PACKAGE_TAIL
+    plural = "" if omitted == 1 else "s"
+    return [
+        *lines[:_PACKAGE_HEAD],
+        f"… {omitted} package change line{plural} omitted",
+        *lines[-_PACKAGE_TAIL:],
+    ]
+
+
+def _drop_adjacent_duplicates(lines: list[str]) -> list[str]:
+    output: list[str] = []
+    for line in lines:
+        if not line:
+            continue
+        if output and output[-1] == line:
+            continue
+        output.append(line)
+    return output

codetool_shell/filters/package_manager/summary.py

@@ -0,0 +1,172 @@
+"""Line classification helpers for package-manager logs."""
+
+from __future__ import annotations
+
+import re
+
+_URL_RE = re.compile(r"\b[A-Za-z][A-Za-z0-9+.-]*://\S+")
+_PATH_RE = re.compile(
+    r"(^|[\s=:\"'`(\[])"
+    r"(?:\.{0,2}/|/|~/|[A-Za-z]:[\\/]|[A-Za-z0-9_.@+-]+/)"
+    r"[A-Za-z0-9_.@+/\-\\]+"
+)
+_FINAL_SUMMARY_RE = re.compile(
+    r"\b(?:"
+    r"successfully installed|installed \d+ packages?|\d+ packages? installed|uninstalled \d+ packages?|"
+    r"prepared \d+ packages?|resolved \d+ packages?|audited \d+ packages?|"
+    r"added \d+ packages?|removed \d+ packages?|changed \d+ packages?|"
+    r"updated \d+ packages?|found \d+ vulnerabilit(?:y|ies)|found 0 vulnerabilities|"
+    r"saved lockfile|installed package|installing collected packages|"
+    r"package operations|lock file operations|writing lock file|installing dependencies from lock file|"
+    r"bundle complete|bundle updated|gems? now installed|bundled gems are installed into|"
+    r"generating autoload files|security vulnerability advisor(?:y|ies)|"
+    r"lock(?:file| file)|frozen|frozen-lockfile|locked|outdated lockfile|"
+    r"lockfile is up to date|immutable install|lockfile would have been modified|"
+    r"no solution found|version solving failed|peer dependenc|unmet peer|incorrect peer dependency|"
+    r"creating virtual environment at|pre-commit installed at|check the log at"
+    r")\b|"
+    r"^\s*(?:dependencies|devDependencies|optionalDependencies|peerDependencies):\s*$|"
+    r"^\s*(?:Done in [\d.]+s\.?|success Saved \d+|success Saved lockfile|"
+    r"info Direct dependencies|info All dependencies)|"
+    r"^\s*==>\s+(?:Caveats|Summary)\b|^\s*🍺|"
+    r"^\s*➤\s+YN(?:0001|0002|0028|0060|0086|[1-9]\d{3}):",
+    re.IGNORECASE,
+)
+_ERROR_WARNING_RE = re.compile(
+    r"(^|\b|[!])(?:error|err|warn|warning|failed|failure|fatal|could not)\b|"
+    r"\bERR_[A-Z0-9_]+\b|^×\s|^\s*➤\s+YN(?:0001|0028):",
+    re.IGNORECASE,
+)
+_HINT_RE = re.compile(
+    r"^\s*(?:hint|note|help):|"
+    r"\b(?:run `?npm audit fix|npm audit fix|composer audit|to address all issues|"
+    r"because .+ depends on|requires .+ but|fixed in:|advisory:|severity:|"
+    r"name:|version:|"
+    r"Run `?yarn explain peer-requirements|peer requirement)\b",
+    re.IGNORECASE,
+)
+_SECURITY_DETAIL_RE = re.compile(
+    r"^\s*(?:name|version|advisory|severity|fixed in):|"
+    r"^\s*\|?\s*(?:Package|Severity|CVE|Title|Affected versions?)\s*\|",
+    re.IGNORECASE,
+)
+_SECURITY_TABLE_VALUE_RE = re.compile(
+    r"\b(?:CVE-\d{4}-\d+|GHSA-[A-Za-z0-9-]+|critical|high|moderate|medium|low)\b",
+    re.IGNORECASE,
+)
+_HOMEBREW_CAVEAT_COMMAND_RE = re.compile(
+    r"^\s*(?:brew\s+(?:services|link|unlink|install|reinstall|restart|start|stop|tap)\b|"
+    r"(?:sudo\s+)?(?:launchctl|systemctl)\b)",
+    re.IGNORECASE,
+)
+_PROGRESS_RE = re.compile(
+    r"^\s*(?:"
+    r"collecting |downloading |downloaded |using cached |fetching |"
+    r"resolving |resolve |resolved, downloaded|preparing |prepared metadata|"
+    r"using cpython|using python|creating virtualenv|creating virtual environment|"
+    r"building wheel|created wheel|stored in directory|"
+    r"requirement already satisfied|installing build dependencies|"
+    r"getting requirements to build wheel|checking if build backend|"
+    r"npm http fetch|npm timing|npm sill|npm verb|"
+    r"loading composer repositories|updating dependencies|generating optimized autoload files|"
+    r"fetching gem metadata|"
+    r"progress: resolved|already up to date|"
+    r"\[\d+/\d+\]\s+(?:resolving|fetching|linking|building)|"
+    r"info (?:no lockfile found|there appears to be trouble|visit https?://)|"
+    r"==>\s+(?:fetching|downloading|pouring|installing|autoremoving)|"
+    r"\[INFO\]\s+(?:initializing|installing|updating) environment for|"
+    r"\[INFO\]\s+(?:once installed|this may take|stashing unstaged files|restored changes)|"
+    r"➤\s+YN0000:.*(?:resolution step|fetch step|link step|done|completed|yarn )|"
+    r"updating crates\.io index|downloading crates|compiling |checking |fresh |"
+    r"installing [A-Za-z0-9_.@+-]+ v?\d"
+    r")",
+    re.IGNORECASE,
+)
+_PACKAGE_CHANGE_RE = re.compile(
+    r"^\s*(?:"
+    r"[+\-~]\s+[@A-Za-z0-9_.-][@A-Za-z0-9_.+\-/]*(?:==|@| v?\d|\d|[<>=~^])|"
+    r"[├└]─\s+[@A-Za-z0-9_.-][@A-Za-z0-9_.+\-/]*@|"
+    r"-\s+(?:Installing|Updating|Upgrading|Downgrading|Removing|Locking|Downloading)\s+[-A-Za-z0-9_./]+(?:\s+\(|\s+v?\d|\s+dev-)|"
+    r"(?:Using|Fetching|Installing)\s+(?!CPython\b|Python\b)[-A-Za-z0-9_.]+(?:\s+\(|\s+\d)|"
+    r"(?:adding|removing|updating|downgrading)\s+[@A-Za-z0-9_.-]+(?:\s+v?\d|@|$)|"
+    r"installed\s+[@A-Za-z0-9_.-]+[@A-Za-z0-9_.+\-/]*(?:@|==| v?\d)"
+    r")",
+    re.IGNORECASE,
+)
+_COMPILER_SPAN_RE = re.compile(r"^\s*-->\s+\S+:\d+:\d+", re.MULTILINE)
+_RUST_ERROR_CODE_RE = re.compile(r"^\s*(?:error|warning)\[E\d+\]", re.MULTILINE)
+_RUST_SOURCE_BAR_RE = re.compile(r"^\s*(?:\d+\s+)?\|", re.MULTILINE)
+
+
+def is_error_warning_line(line: str) -> bool:
+    return _ERROR_WARNING_RE.search(line.strip()) is not None
+
+
+def is_final_summary_line(line: str) -> bool:
+    return _FINAL_SUMMARY_RE.search(line) is not None
+
+
+def is_hint_line(line: str) -> bool:
+    return (
+        _HINT_RE.search(line) is not None
+        or _SECURITY_DETAIL_RE.search(line) is not None
+        or _SECURITY_TABLE_VALUE_RE.search(line) is not None
+        or _HOMEBREW_CAVEAT_COMMAND_RE.search(line) is not None
+    )
+
+
+def has_reference(line: str) -> bool:
+    return _URL_RE.search(line) is not None or _PATH_RE.search(line) is not None
+
+
+def is_package_change_line(line: str) -> bool:
+    return _PACKAGE_CHANGE_RE.search(line) is not None
+
+
+def is_progress_line(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped:
+        return False
+    if set(stripped) <= {"-", "=", ">", ".", " ", "#"}:
+        return True
+    return _PROGRESS_RE.search(stripped) is not None
+
+
+def is_important_line(line: str) -> bool:
+    """Return whether a package-manager line must be preserved."""
+
+    if is_progress_line(line):
+        return (
+            is_error_warning_line(line)
+            or is_final_summary_line(line)
+            or is_hint_line(line)
+        )
+
+    return (
+        is_error_warning_line(line)
+        or is_final_summary_line(line)
+        or is_hint_line(line)
+        or has_reference(line)
+    )
+
+
+def has_compiler_diagnostics(text: str) -> bool:
+    """Return true for Rust/compiler diagnostic spans outside this filter scope."""
+
+    lower = text.lower()
+    return (
+        _RUST_ERROR_CODE_RE.search(text) is not None
+        or (
+            _COMPILER_SPAN_RE.search(text) is not None
+            and (
+                _RUST_SOURCE_BAR_RE.search(text) is not None
+                or "could not compile" in lower
+                or "error:" in lower
+            )
+        )
+        or "could not compile" in lower
+    )
+
+
+def normalize_selected_line(line: str) -> str:
+    return line.strip()

codetool_shell/filters/pipeline.py

@@ -0,0 +1,65 @@
+"""Filter pipeline orchestration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from .build_compiler import compress_build_compiler_diagnostics_output
+from .ci_job_log import compress_ci_job_log_output
+from .diff import compress_diff_output
+from .generic_log import compress_generic_log_output
+from .git import compress_git_output
+from .html_cleanup import compress_html_cleanup_output
+from .json_payload import compress_json_payload_output
+from .listing import compress_listing_output
+from .log_template import compress_log_template_output
+from .opaque_payload import compress_opaque_payload_output
+from .package_manager import compress_package_manager_output
+from .rg import compress_rg_output
+from .system_output import compress_system_output
+from .table import compress_table_output
+from .test_runner import compress_test_runner_output
+from .text import score
+from .traceback import compress_traceback_output
+
+FilterFn = Callable[[str], str]
+
+
+@dataclass(frozen=True)
+class TextFilter:
+    """A named output filter in the compression pipeline."""
+
+    name: str
+    apply: FilterFn
+
+
+FILTER_PIPELINE: tuple[TextFilter, ...] = (
+    TextFilter("git", compress_git_output),
+    TextFilter("diff", compress_diff_output),
+    TextFilter("test-runner", compress_test_runner_output),
+    TextFilter("ci-job-log", compress_ci_job_log_output),
+    TextFilter("traceback", compress_traceback_output),
+    TextFilter("json", compress_json_payload_output),
+    TextFilter("html", compress_html_cleanup_output),
+    TextFilter("opaque-payload", compress_opaque_payload_output),
+    TextFilter("system-output", compress_system_output),
+    TextFilter("table", compress_table_output),
+    TextFilter("listing", compress_listing_output),
+    TextFilter("build-compiler", compress_build_compiler_diagnostics_output),
+    TextFilter("rg", compress_rg_output),
+    TextFilter("package-manager", compress_package_manager_output),
+    TextFilter("log-template", compress_log_template_output),
+    TextFilter("generic-log", compress_generic_log_output),
+)
+
+
+def apply_filter_pipeline(text: str) -> str:
+    """Run all dedicated filters and keep only size-improving results."""
+
+    current = text
+    for text_filter in FILTER_PIPELINE:
+        candidate = text_filter.apply(current)
+        if score(candidate) < score(current):
+            current = candidate
+    return current