codetool-shell 0.1.1__py3-none-win_arm64.whl

codetool_shell/filters/build_compiler/summary.py

@@ -0,0 +1,617 @@
+"""Line classification helpers for build/compiler diagnostics."""
+
+from __future__ import annotations
+
+import re
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
+_RUST_DIAGNOSTIC_RE = re.compile(r"^\s*(?:error|warning)(?:\[[A-Za-z0-9_]+\])?:")
+_RUST_SPAN_RE = re.compile(r"^\s*-->\s+\S+:\d+:\d+")
+_RUST_SOURCE_BAR_RE = re.compile(r"^\s*(?:\d+\s+)?\|")
+_TSC_PARENS_RE = re.compile(
+    r"^\S.*\.(?:ts|tsx|js|jsx)\(\d+,\d+\):\s+(?:error|warning)\s+TS\d+:",
+    re.IGNORECASE,
+)
+_TSC_PRETTY_RE = re.compile(
+    r"^\S.*\.(?:ts|tsx|js|jsx):\d+:\d+\s+-\s+(?:error|warning)\s+TS\d+:",
+    re.IGNORECASE,
+)
+_ESLINT_ISSUE_RE = re.compile(
+    r"^\s*\d+:\d+\s+(?:error|warning)\s+.+\s+[@A-Za-z0-9_./-]+$",
+    re.IGNORECASE,
+)
+_ESLINT_COMPACT_RE = re.compile(
+    r"^\S.*\.(?:ts|tsx|js|jsx):\d+:\d+:\s+(?:error|warning)\s+.+\s+[@A-Za-z0-9_./-]+$",
+    re.IGNORECASE,
+)
+_ESLINT_FILE_HEADER_RE = re.compile(r"^(?:\.{0,2}/|/|[A-Za-z]:[\\/]|~?/)?\S+\.(?:js|jsx|ts|tsx)$")
+_ESLINT_SUMMARY_RE = re.compile(r"\b\d+\s+problems?\b|\b\d+\s+errors?\b.*\b\d+\s+warnings?\b", re.I)
+_MYPY_RE = re.compile(
+    r"^(?P<path>.+?\.pyi?):(?P<location>\d+(?::\d+)?):\s+"
+    r"(?P<detail>(?:error|warning|note):\s+.+)$",
+    re.IGNORECASE,
+)
+_RUFF_RE = re.compile(
+    r"^\S.*\.pyi?:\d+:\d+:\s+(?:[A-Z]{1,4}\d{3,4})\b\s+.+$"
+)
+_PYRIGHT_RE = re.compile(
+    r"^\s*\S.*\.pyi?:\d+:\d+\s+-\s+"
+    r"(?:error|warning|information):\s+.+$",
+    re.IGNORECASE,
+)
+_PYRIGHT_FILE_HEADER_RE = re.compile(r"^(?:\.{0,2}/|/|[A-Za-z]:[\\/]|~?/)?\S+\.pyi?$")
+_BIOME_LOCATION_RULE_RE = re.compile(
+    r"^\S.*\.(?:js|jsx|ts|tsx|mjs|cjs|json|jsonc|css|md|mdx|vue|svelte|astro)"
+    r":\d+:\d+\s+.+\b(?:lint|style|suspicious|correctness|complexity|nursery|a11y)/"
+    r"[A-Za-z0-9_./-]+",
+    re.IGNORECASE,
+)
+_OXLINT_DIAGNOSTIC_RE = re.compile(
+    r"^\s*(?:×|!|error|warning)\s+(?:eslint|oxlint)\([^)]+\):\s+.+$",
+    re.IGNORECASE,
+)
+_OXLINT_FRAME_RE = re.compile(
+    r"^\s*╭─\[.+\.(?:js|jsx|ts|tsx|mjs|cjs):\d+:\d+\]",
+    re.IGNORECASE,
+)
+_SHELLCHECK_HEADER_RE = re.compile(r"^In .+ line \d+:$", re.IGNORECASE)
+_SHELLCHECK_CODE_RE = re.compile(r"\bSC\d{4}\b")
+_SHELLCHECK_GCC_RE = re.compile(
+    r"^\S.*:\d+:\d+:\s+(?:error|warning|note|style|info):\s+.+\s+\[SC\d{4}\]",
+    re.IGNORECASE,
+)
+_MARKDOWNLINT_RE = re.compile(
+    r"^\S.*\.mdx?:\d+(?::\d+)?\s+MD\d{3}(?:/[A-Za-z0-9-]+)?\s+.+$",
+    re.IGNORECASE,
+)
+_YAMLLINT_PARSABLE_RE = re.compile(
+    r"^\S.*\.ya?ml:\d+:\d+:\s+\[(?:error|warning)\]\s+.+\([A-Za-z0-9_-]+\)",
+    re.IGNORECASE,
+)
+_YAMLLINT_GROUPED_RE = re.compile(
+    r"^\s*\d+:\d+\s+(?:error|warning)\s+.+\([A-Za-z0-9_-]+\)",
+    re.IGNORECASE,
+)
+_YAMLLINT_FILE_HEADER_RE = re.compile(r"^(?:\.{0,2}/|/|[A-Za-z]:[\\/]|~?/)?\S+\.ya?ml$")
+_GOLANGCI_LINTERS = (
+    "asasalint",
+    "asciicheck",
+    "bidichk",
+    "bodyclose",
+    "canonicalheader",
+    "copyloopvar",
+    "cyclop",
+    "decorder",
+    "depguard",
+    "dogsled",
+    "dupl",
+    "durationcheck",
+    "errcheck",
+    "errchkjson",
+    "errorlint",
+    "exhaustive",
+    "exhaustruct",
+    "forbidigo",
+    "forcetypeassert",
+    "gci",
+    "gocheckcompilerdirectives",
+    "gochecknoglobals",
+    "gochecknoinits",
+    "gochecksumtype",
+    "gocognit",
+    "goconst",
+    "gocritic",
+    "gocyclo",
+    "godot",
+    "godox",
+    "gofmt",
+    "gofumpt",
+    "goheader",
+    "goimports",
+    "gomoddirectives",
+    "gomodguard",
+    "goprintffuncname",
+    "gosec",
+    "gosimple",
+    "gosmopolitan",
+    "govet",
+    "grouper",
+    "iface",
+    "importas",
+    "inamedparam",
+    "ineffassign",
+    "interfacebloat",
+    "intrange",
+    "lll",
+    "loggercheck",
+    "maintidx",
+    "makezero",
+    "mirror",
+    "misspell",
+    "mnd",
+    "musttag",
+    "nakedret",
+    "nestif",
+    "nilerr",
+    "nilnil",
+    "nlreturn",
+    "noctx",
+    "nolintlint",
+    "nonamedreturns",
+    "paralleltest",
+    "perfsprint",
+    "prealloc",
+    "predeclared",
+    "promlinter",
+    "protogetter",
+    "reassign",
+    "recvcheck",
+    "revive",
+    "rowserrcheck",
+    "sloglint",
+    "spancheck",
+    "sqlclosecheck",
+    "staticcheck",
+    "stylecheck",
+    "tagalign",
+    "tagliatelle",
+    "testableexamples",
+    "testifylint",
+    "thelper",
+    "tparallel",
+    "typecheck",
+    "unconvert",
+    "unparam",
+    "unused",
+    "usestdlibvars",
+    "usetesting",
+    "varnamelen",
+    "wastedassign",
+    "whitespace",
+    "wrapcheck",
+    "wsl",
+    "zerologlint",
+)
+_GOLANGCI_RE = re.compile(
+    r"^(?P<path>\S.*\.go):(?P<location>\d+:\d+):\s+"
+    r"(?P<detail>.+\((?P<linter>[A-Za-z0-9_-]+)\))$"
+)
+_C_FAMILY_DIAGNOSTIC_RE = re.compile(
+    r"^\S.*\.(?:c|cc|cpp|cxx|h|hh|hpp|m|mm|swift):\d+:\d+:\s+"
+    r"(?:fatal error|error|warning|note):\s+.+$",
+    re.IGNORECASE,
+)
+_GO_BUILD_DIAGNOSTIC_RE = re.compile(
+    r"^\S.*\.go:\d+(?::\d+)?:\s+"
+    r"(?:undefined:|declared and not used:|cannot use |too many arguments|"
+    r"not enough arguments|assignment mismatch|syntax error:|"
+    r"imported and not used:|.+\b(?:is not a type|has no field or method)\b).+$"
+)
+_GO_BUILD_PACKAGE_RE = re.compile(r"^#\s+(?:command-line-arguments|\S+[./]\S+)$")
+_MSBUILD_DIAGNOSTIC_RE = re.compile(
+    r"^(?:(?:\S.*\.(?:cs|vb|fs)\(\d+,\d+\):|[A-Z][A-Z0-9]*\s+:)\s+)?(?:fatal\s+)?"
+    r"(?:error|warning)\s+(?:CS|MSB|NETSDK|NU)\d+:.+$",
+    re.IGNORECASE,
+)
+_MSBUILD_TOTAL_RE = re.compile(r"^\s*\d+\s+(?:Warning|Error)\(s\)$", re.IGNORECASE)
+_MAVEN_GRADLE_ERROR_RE = re.compile(r"^\[(?:ERROR|WARNING)\]\s+.+$")
+_GRADLE_TASK_FAILED_RE = re.compile(r"^>\s+Task\s+.+\s+FAILED$")
+_MAKE_NINJA_CMAKE_RE = re.compile(
+    r"^(?:make(?:\[\d+\])?: \*\*\* .+|ninja: build stopped: .+|"
+    r"CMake Error at .+|CMake Warning at .+)$",
+    re.IGNORECASE,
+)
+_NX_TURBO_FAILURE_RE = re.compile(
+    r"^(?:Failed tasks?:|Tasks:\s+.*\bfailed\b.*|ERROR\s+run failed:|"
+    r".+(?:#|:)(?:build|test|lint|typecheck):\s+command (?:failed|exited).*)$",
+    re.IGNORECASE,
+)
+_GOLANGCI_RUNNER_RE = re.compile(
+    r"^(?:ERRO|level=error\b|level=fatal\b).*(?:running error|context loading failed|"
+    r"can't run linter|failed to load|golangci-lint)",
+    re.IGNORECASE,
+)
+_LINT_CONTEXT_RE = re.compile(
+    r"^\s*(?:[>|·╭╰├│]|[0-9]+\s*│|[│╰╭].*)$"
+)
+_NOTE_HELP_RE = re.compile(r"^\s*(?:=\s*)?(?:note|help):", re.IGNORECASE)
+_FINAL_SUMMARY_RE = re.compile(
+    r"(could not compile|aborting due to|error: build failed|"
+    r"warning: .+ generated \d+ warnings?|"
+    r"finished `|found \d+ errors? in \d+ files?|"
+    r"found \d+ errors?|found \d+ warnings?|"
+    r"\d+\s+errors?,\s+\d+\s+warnings?,\s+\d+\s+informations?|"
+    r"found \d+\s+warnings?\s+and\s+\d+\s+errors?|"
+    r"\d+\s+issues?:|checked \d+ files?|"
+    r"success: no issues found|"
+    r"\d+\s+problems?\s+\(\d+\s+errors?,\s+\d+\s+warnings?\))",
+    re.IGNORECASE,
+)
+_PROGRESS_RE = re.compile(
+    r"^\s*(?:Compiling|Checking|Fresh|Building|Running|Downloading|Downloaded|"
+    r"Blocking waiting|Waiting|Starting compilation|File change detected|Linting)\b",
+    re.IGNORECASE,
+)
+_ERROR_WORD_RE = re.compile(r"(?<![A-Za-z0-9_])(?:error|fatal)(?![A-Za-z0-9_])", re.IGNORECASE)
+_WARNING_WORD_RE = re.compile(r"(?<![A-Za-z0-9_])warning(?![A-Za-z0-9_])", re.IGNORECASE)
+_NONZERO_ERROR_COUNT_RE = re.compile(r"\b[1-9]\d*\s+errors?\b", re.IGNORECASE)
+_NONZERO_WARNING_COUNT_RE = re.compile(r"\b[1-9]\d*\s+warnings?\b", re.IGNORECASE)
+_ZERO_ERROR_WARNING_SUMMARY_RE = re.compile(
+    r"\b(?:0\s+errors?.*\b[1-9]\d*\s+warnings?|"
+    r"[1-9]\d*\s+warnings?\s+and\s+0\s+errors?)\b",
+    re.IGNORECASE,
+)
+_WARNING_DIAGNOSTIC_RE = re.compile(
+    r"^\s*(?:\S.*:\d+:\d+\s+-\s+)?warning\b|^\s*[×!]\s+.+\(.*\):",
+    re.IGNORECASE,
+)
+_FAILURE_RE = re.compile(
+    r"\b(failed|failure)\b|could not compile|aborting due to|running error",
+    re.IGNORECASE,
+)
+
+
+def strip_ansi(text: str) -> str:
+    return _ANSI_RE.sub("", text)
+
+
+def is_rust_diagnostic_line(line: str) -> bool:
+    return _RUST_DIAGNOSTIC_RE.match(line) is not None
+
+
+def is_rust_span_line(line: str) -> bool:
+    return _RUST_SPAN_RE.match(line) is not None
+
+
+def is_rust_source_bar_line(line: str) -> bool:
+    return _RUST_SOURCE_BAR_RE.match(line) is not None
+
+
+def is_tsc_diagnostic_line(line: str) -> bool:
+    return _TSC_PARENS_RE.match(line) is not None or _TSC_PRETTY_RE.match(line) is not None
+
+
+def is_eslint_issue_line(line: str) -> bool:
+    return _ESLINT_ISSUE_RE.match(line) is not None or _ESLINT_COMPACT_RE.match(line) is not None
+
+
+def is_eslint_file_header(line: str) -> bool:
+    stripped = line.strip()
+    return " " not in stripped and _ESLINT_FILE_HEADER_RE.match(stripped) is not None
+
+
+def is_eslint_summary_line(line: str) -> bool:
+    stripped = line.strip()
+    return stripped.startswith("✖") or _ESLINT_SUMMARY_RE.search(stripped) is not None
+
+
+def is_mypy_diagnostic_line(line: str) -> bool:
+    return _MYPY_RE.match(line) is not None
+
+
+def parse_mypy_diagnostic_line(line: str) -> tuple[str, str, str] | None:
+    match = _MYPY_RE.match(line)
+    if match is None:
+        return None
+    return match.group("path"), match.group("location"), match.group("detail")
+
+
+def is_ruff_diagnostic_line(line: str) -> bool:
+    return _RUFF_RE.match(line.strip()) is not None
+
+
+def is_ruff_summary_line(line: str) -> bool:
+    lower = line.strip().lower()
+    return (
+        lower.startswith("found ") and "error" in lower
+        or "fixable with the" in lower
+        or lower.startswith("[*] ")
+        or lower.startswith("all checks passed")
+    )
+
+
+def is_pyright_diagnostic_line(line: str) -> bool:
+    return _PYRIGHT_RE.match(line.strip()) is not None
+
+
+def is_pyright_summary_line(line: str) -> bool:
+    lower = line.strip().lower()
+    return (
+        " errors," in lower
+        and (" warning," in lower or " warnings," in lower)
+        and (" information" in lower or " informations" in lower)
+    )
+
+
+def is_pyright_file_header(line: str) -> bool:
+    stripped = line.strip()
+    return " " not in stripped and _PYRIGHT_FILE_HEADER_RE.match(stripped) is not None
+
+
+def is_biome_diagnostic_line(line: str) -> bool:
+    stripped = line.strip()
+    return _BIOME_LOCATION_RULE_RE.match(stripped) is not None
+
+
+def is_biome_summary_line(line: str) -> bool:
+    lower = line.strip().lower()
+    return (
+        lower.startswith("found ") and ("error" in lower or "warning" in lower)
+        or lower.startswith("checked ") and " file" in lower
+        or "no fixes applied" in lower
+    )
+
+
+def is_oxlint_diagnostic_line(line: str) -> bool:
+    return _OXLINT_DIAGNOSTIC_RE.match(line.strip()) is not None
+
+
+def is_oxlint_frame_line(line: str) -> bool:
+    return _OXLINT_FRAME_RE.match(line.strip()) is not None
+
+
+def is_oxlint_summary_line(line: str) -> bool:
+    lower = line.strip().lower()
+    return lower.startswith("found ") and ("warning" in lower or "error" in lower)
+
+
+def is_shellcheck_header_line(line: str) -> bool:
+    return _SHELLCHECK_HEADER_RE.match(line.strip()) is not None
+
+
+def is_shellcheck_diagnostic_line(line: str) -> bool:
+    stripped = line.strip()
+    return (
+        is_shellcheck_gcc_diagnostic_line(stripped)
+        or _SHELLCHECK_CODE_RE.search(stripped) is not None
+    )
+
+
+def is_shellcheck_gcc_diagnostic_line(line: str) -> bool:
+    return _SHELLCHECK_GCC_RE.match(line.strip()) is not None
+
+
+def is_markdownlint_diagnostic_line(line: str) -> bool:
+    return _MARKDOWNLINT_RE.match(line.strip()) is not None
+
+
+def is_yamllint_diagnostic_line(line: str) -> bool:
+    stripped = line.strip()
+    return (
+        _YAMLLINT_PARSABLE_RE.match(stripped) is not None
+        or _YAMLLINT_GROUPED_RE.match(line) is not None
+    )
+
+
+def is_yamllint_file_header(line: str) -> bool:
+    stripped = line.strip()
+    return " " not in stripped and _YAMLLINT_FILE_HEADER_RE.match(stripped) is not None
+
+
+def is_golangci_lint_issue_line(line: str) -> bool:
+    match = _GOLANGCI_RE.match(line.strip())
+    return match is not None and match.group("linter").lower() in _GOLANGCI_LINTERS
+
+
+def parse_golangci_lint_issue_line(line: str) -> tuple[str, str, str] | None:
+    match = _GOLANGCI_RE.match(line.strip())
+    if match is None or match.group("linter").lower() not in _GOLANGCI_LINTERS:
+        return None
+    return match.group("path"), match.group("location"), match.group("detail")
+
+
+def is_golangci_lint_runner_error_line(line: str) -> bool:
+    return _GOLANGCI_RUNNER_RE.match(line.strip()) is not None
+
+
+def is_golangci_lint_summary_line(line: str) -> bool:
+    lower = line.strip().lower()
+    return lower.endswith("issues:") or lower.endswith("issue:") or "issues before processing" in lower
+
+
+def is_c_family_diagnostic_line(line: str) -> bool:
+    return _C_FAMILY_DIAGNOSTIC_RE.match(line.strip()) is not None
+
+
+def is_c_family_source_context_line(line: str) -> bool:
+    return re.match(r"^\s*(?:\d+\s*)?\|", line.rstrip()) is not None
+
+
+def is_go_build_package_header(line: str) -> bool:
+    return _GO_BUILD_PACKAGE_RE.match(line.strip()) is not None
+
+
+def is_go_build_diagnostic_line(line: str) -> bool:
+    return _GO_BUILD_DIAGNOSTIC_RE.match(line.strip()) is not None
+
+
+def is_msbuild_diagnostic_line(line: str) -> bool:
+    return _MSBUILD_DIAGNOSTIC_RE.match(line.strip()) is not None
+
+
+def is_msbuild_summary_line(line: str) -> bool:
+    stripped = line.strip()
+    lower = stripped.lower()
+    return (
+        stripped.startswith("Build FAILED")
+        or stripped.startswith("Build succeeded")
+        or _MSBUILD_TOTAL_RE.match(stripped) is not None
+        or "time elapsed" in lower
+    )
+
+
+def is_maven_gradle_diagnostic_line(line: str) -> bool:
+    stripped = line.strip()
+    lower = stripped.lower()
+    return (
+        _MAVEN_GRADLE_ERROR_RE.match(stripped) is not None
+        or _GRADLE_TASK_FAILED_RE.match(stripped) is not None
+        or stripped.startswith(("FAILURE:", "* What went wrong:", "* Try:"))
+        or "build failed" in lower
+        or "build failure" in lower
+        or "execution failed for task" in lower
+        or "surefire-reports" in lower
+        or "test report" in lower
+    )
+
+
+def is_make_ninja_cmake_diagnostic_line(line: str) -> bool:
+    stripped = line.strip()
+    return _MAKE_NINJA_CMAKE_RE.match(stripped) is not None
+
+
+def is_nx_turbo_diagnostic_line(line: str) -> bool:
+    stripped = line.strip()
+    lower = stripped.lower()
+    return (
+        _NX_TURBO_FAILURE_RE.match(stripped) is not None
+        or stripped.startswith(("NX   ", "• Running target", "Failed:"))
+        or (stripped.startswith("- ") and ("#" in stripped or ":" in stripped))
+        or "failed tasks:" in lower
+        or "command exited" in lower
+    )
+
+
+def is_swift_xcode_failure_line(line: str) -> bool:
+    stripped = line.strip()
+    return stripped == "** BUILD FAILED **" or stripped.startswith("The following build commands failed:")
+
+
+def is_lint_source_context_line(line: str) -> bool:
+    stripped = line.rstrip()
+    return (
+        _LINT_CONTEXT_RE.match(stripped) is not None
+        or is_rust_source_bar_line(stripped)
+        or is_oxlint_frame_line(stripped)
+        or is_c_family_source_context_line(line)
+    )
+
+
+def is_note_help_line(line: str) -> bool:
+    stripped = line.strip()
+    return _NOTE_HELP_RE.match(line) is not None or stripped.lower().startswith("did you mean:")
+
+
+def is_final_summary_line(line: str) -> bool:
+    return (
+        _FINAL_SUMMARY_RE.search(line) is not None
+        or is_eslint_summary_line(line)
+        or is_ruff_summary_line(line)
+        or is_pyright_summary_line(line)
+        or is_biome_summary_line(line)
+        or is_oxlint_summary_line(line)
+        or is_golangci_lint_summary_line(line)
+        or is_msbuild_summary_line(line)
+        or is_maven_gradle_diagnostic_line(line)
+        or is_make_ninja_cmake_diagnostic_line(line)
+        or is_nx_turbo_diagnostic_line(line)
+        or is_swift_xcode_failure_line(line)
+    )
+
+
+def is_progress_line(line: str) -> bool:
+    return _PROGRESS_RE.match(line) is not None
+
+
+def is_important_diagnostic_line(line: str) -> bool:
+    return (
+        is_rust_diagnostic_line(line)
+        or is_rust_span_line(line)
+        or is_rust_source_bar_line(line)
+        or is_tsc_diagnostic_line(line)
+        or is_eslint_issue_line(line)
+        or is_mypy_diagnostic_line(line)
+        or is_ruff_diagnostic_line(line)
+        or is_pyright_diagnostic_line(line)
+        or is_biome_diagnostic_line(line)
+        or is_oxlint_diagnostic_line(line)
+        or is_oxlint_frame_line(line)
+        or is_shellcheck_header_line(line)
+        or is_shellcheck_diagnostic_line(line)
+        or is_markdownlint_diagnostic_line(line)
+        or is_yamllint_diagnostic_line(line)
+        or is_golangci_lint_issue_line(line)
+        or is_golangci_lint_runner_error_line(line)
+        or is_c_family_diagnostic_line(line)
+        or is_go_build_package_header(line)
+        or is_go_build_diagnostic_line(line)
+        or is_msbuild_diagnostic_line(line)
+        or is_msbuild_summary_line(line)
+        or is_maven_gradle_diagnostic_line(line)
+        or is_make_ninja_cmake_diagnostic_line(line)
+        or is_nx_turbo_diagnostic_line(line)
+        or is_swift_xcode_failure_line(line)
+        or is_lint_source_context_line(line)
+        or is_note_help_line(line)
+        or is_final_summary_line(line)
+    )
+
+
+def is_diagnostic_file_header(kind: str, line: str) -> bool:
+    if kind == "eslint":
+        return is_eslint_file_header(line)
+    if kind == "pyright":
+        return is_pyright_file_header(line)
+    if kind == "yamllint":
+        return is_yamllint_file_header(line)
+    if kind == "go-build":
+        return is_go_build_package_header(line)
+    return False
+
+
+def diagnostic_context_budget(kind: str, line: str) -> int:
+    if is_tsc_diagnostic_line(line):
+        return 2
+    if kind == "shellcheck" and (
+        is_shellcheck_header_line(line) or is_note_help_line(line)
+    ):
+        return 3 if is_shellcheck_header_line(line) else 1
+    if kind in {"ruff", "biome", "oxlint"} and (
+        is_ruff_diagnostic_line(line)
+        or is_biome_diagnostic_line(line)
+        or is_oxlint_diagnostic_line(line)
+        or is_oxlint_frame_line(line)
+    ):
+        return 4
+    if is_c_family_diagnostic_line(line):
+        return 3
+    return 0
+
+
+def is_safe_snippet_line(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped or len(stripped) > 240:
+        return False
+    if is_progress_line(stripped) or is_important_diagnostic_line(stripped):
+        return False
+    return True
+
+
+def has_error_signal(lines: list[str]) -> bool:
+    for line in lines:
+        lower = line.lower()
+        if _NONZERO_ERROR_COUNT_RE.search(line) is not None:
+            return True
+        if _ZERO_ERROR_WARNING_SUMMARY_RE.search(line) is not None:
+            continue
+        if _FAILURE_RE.search(line) is not None or "error[" in lower:
+            return True
+        if (
+            _ERROR_WORD_RE.search(line) is not None
+            and _WARNING_DIAGNOSTIC_RE.search(line) is None
+        ):
+            return True
+    return False
+
+
+def has_warning_signal(lines: list[str]) -> bool:
+    return any(
+        _NONZERO_WARNING_COUNT_RE.search(line) is not None
+        or _WARNING_WORD_RE.search(line) is not None
+        or "warning[" in line.lower()
+        for line in lines
+    )
+
+
+def normalize_line(line: str) -> str:
+    return line.strip()

codetool_shell/filters/ci_job_log/__init__.py

@@ -0,0 +1,7 @@
+"""CI/job log shellion filter."""
+
+from __future__ import annotations
+
+from .reducer import compress_ci_job_log_output
+
+__all__ = ["compress_ci_job_log_output"]

codetool_shell/filters/ci_job_log/detector.py

@@ -0,0 +1,64 @@
+"""Detect conservative CI/job log shapes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .summary import (
+    extract_group_step,
+    is_actions_marker,
+    is_error_annotation,
+    is_failure_line,
+    is_group_end,
+    is_warning_line,
+    parse_ci_line,
+)
+
+
+@dataclass(frozen=True)
+class CiLogSignal:
+    """Detected CI log outcome signals."""
+
+    failed: bool
+    warning: bool
+
+
+def detect_ci_job_log(lines: list[str]) -> CiLogSignal | None:
+    """Return a strong GitHub Actions log signal, or ``None``."""
+
+    parsed_lines = [parse_ci_line(line) for line in lines if line.strip()]
+    if len(parsed_lines) < 3:
+        return None
+
+    prefixed_count = sum(1 for line in parsed_lines if line.had_ci_prefix)
+    tab_prefixed_count = sum(
+        1 for line in parsed_lines if line.had_ci_prefix and line.job and line.step
+    )
+    marker_count = sum(1 for line in parsed_lines if is_actions_marker(line.message))
+    group_count = sum(
+        1
+        for line in parsed_lines
+        if extract_group_step(line.message) is not None or is_group_end(line.message)
+    )
+    annotation_count = sum(
+        1
+        for line in parsed_lines
+        if is_error_annotation(line.message) or is_warning_line(line.message)
+    )
+
+    has_strong_prefix_shape = prefixed_count >= 2 and marker_count >= 1
+    has_strong_tab_shape = tab_prefixed_count >= 2 and marker_count >= 1
+    has_workflow_command_shape = marker_count >= 2 and (
+        group_count >= 1 or annotation_count >= 1
+    )
+    if not (
+        has_strong_prefix_shape
+        or has_strong_tab_shape
+        or has_workflow_command_shape
+    ):
+        return None
+
+    return CiLogSignal(
+        failed=any(is_failure_line(line.message) for line in parsed_lines),
+        warning=any(is_warning_line(line.message) for line in parsed_lines),
+    )