codetool-shell 0.1.1__py3-none-win_amd64.whl

codetool_shell/filters/table/detector.py

@@ -0,0 +1,244 @@
+"""Conservative parsers for structured table output."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class StructuredTable:
+    """Parsed table lines ready for row reduction."""
+
+    header_lines: tuple[str, ...]
+    rows: tuple[str, ...]
+    footer_lines: tuple[str, ...] = ()
+
+
+_MIN_DATA_ROWS = 9
+_PSQL_FOOTER_RE = re.compile(r"^\(\d+ rows?\)$")
+_PATH_LOCATION_RE = re.compile(r"^(.+?):([1-9]\d*)(?::([1-9]\d*))?:(.*)$")
+
+
+def parse_structured_table(lines: list[str]) -> StructuredTable | None:
+    """Return a parsed safe table, or ``None`` if the shape is uncertain."""
+
+    if _has_blocking_context(lines):
+        return None
+
+    for parser in (
+        _parse_mysql_box_table,
+        _parse_psql_table,
+        _parse_markdown_pipe_table,
+        _parse_sqlite_column_table,
+    ):
+        parsed = parser(lines)
+        if parsed is not None and len(parsed.rows) >= _MIN_DATA_ROWS:
+            return parsed
+    return None
+
+
+def _parse_psql_table(lines: list[str]) -> StructuredTable | None:
+    if len(lines) < _MIN_DATA_ROWS + 2:
+        return None
+
+    footer_lines: tuple[str, ...] = ()
+    body = lines
+    if lines and _PSQL_FOOTER_RE.match(lines[-1].strip()):
+        footer_lines = (lines[-1],)
+        body = lines[:-1]
+
+    if len(body) < _MIN_DATA_ROWS + 2:
+        return None
+
+    header, separator = body[0], body[1]
+    if "|" not in header or not _is_psql_separator(separator):
+        return None
+
+    column_count = len(separator.strip().split("+"))
+    if column_count < 2 or len(header.split("|")) != column_count:
+        return None
+
+    rows = body[2:]
+    if any(row.count("|") != column_count - 1 for row in rows):
+        return None
+
+    return StructuredTable((header, separator), tuple(rows), footer_lines)
+
+
+def _parse_sqlite_column_table(lines: list[str]) -> StructuredTable | None:
+    if len(lines) < _MIN_DATA_ROWS + 2:
+        return None
+
+    header, separator = lines[0], lines[1]
+    if "|" in header or "|" in separator or "+" in separator:
+        return None
+    if not _is_sqlite_separator(separator):
+        return None
+
+    header_columns = _split_columns(header)
+    separator_columns = _split_columns(separator)
+    if len(header_columns) != len(separator_columns) or len(header_columns) < 2:
+        return None
+    if any(not _is_safe_header_cell(column) for column in header_columns):
+        return None
+
+    rows = lines[2:]
+    valid_rows = 0
+    for row in rows:
+        if "|" in row or _looks_like_path_location_line(row) or _looks_like_log_line(row):
+            return None
+        if len(_split_columns(row)) >= 2:
+            valid_rows += 1
+
+    if valid_rows * 4 < len(rows) * 3:
+        return None
+
+    return StructuredTable((header, separator), tuple(rows))
+
+
+def _parse_mysql_box_table(lines: list[str]) -> StructuredTable | None:
+    if len(lines) < _MIN_DATA_ROWS + 4:
+        return None
+    if not (
+        _is_mysql_border(lines[0])
+        and _is_mysql_row(lines[1])
+        and _is_mysql_border(lines[2])
+    ):
+        return None
+
+    column_count = lines[0].count("+") - 1
+    if column_count < 2 or lines[1].count("|") != column_count + 1:
+        return None
+
+    row_end: int | None = None
+    for index in range(3, len(lines)):
+        line = lines[index]
+        if _is_mysql_border(line):
+            row_end = index
+            break
+        if not _is_mysql_row(line) or line.count("|") != column_count + 1:
+            return None
+
+    if row_end is None:
+        return None
+
+    rows = lines[3:row_end]
+    footer_lines = lines[row_end:]
+    if len(footer_lines) > 1 and any(
+        not _is_mysql_footer_line(line) for line in footer_lines[1:]
+    ):
+        return None
+
+    return StructuredTable(tuple(lines[:3]), tuple(rows), tuple(footer_lines))
+
+
+def _parse_markdown_pipe_table(lines: list[str]) -> StructuredTable | None:
+    if len(lines) < _MIN_DATA_ROWS + 2:
+        return None
+    if not (_is_markdown_row(lines[0]) and _is_markdown_separator(lines[1])):
+        return None
+
+    rows = lines[2:]
+    if any(not _is_markdown_row(row) for row in rows):
+        return None
+
+    return StructuredTable((lines[0], lines[1]), tuple(rows))
+
+
+def _has_blocking_context(lines: list[str]) -> bool:
+    if not lines or any(not line.strip() for line in lines):
+        return True
+    if any(line.lstrip().startswith(("```", "~~~")) for line in lines):
+        return True
+    if any(_looks_like_traceback_line(line) for line in lines):
+        return True
+    return _looks_like_path_location_output(lines)
+
+
+def _is_psql_separator(line: str) -> bool:
+    parts = line.strip().split("+")
+    return len(parts) >= 2 and all(
+        len(part.strip()) >= 2 and set(part.strip()) == {"-"} for part in parts
+    )
+
+
+def _is_sqlite_separator(line: str) -> bool:
+    columns = _split_columns(line)
+    return len(columns) >= 2 and all(
+        len(column) >= 2 and set(column) == {"-"} for column in columns
+    )
+
+
+def _split_columns(line: str) -> list[str]:
+    return [column.strip() for column in re.split(r"\s{2,}", line.strip()) if column.strip()]
+
+
+def _is_safe_header_cell(cell: str) -> bool:
+    return bool(re.fullmatch(r"[A-Za-z0-9_.#()/ -]{1,80}", cell))
+
+
+def _is_mysql_border(line: str) -> bool:
+    return (
+        line.startswith("+")
+        and line.endswith("+")
+        and line.count("+") >= 3
+        and all(char in "+-" for char in line)
+    )
+
+
+def _is_mysql_row(line: str) -> bool:
+    return line.startswith("|") and line.endswith("|") and line.count("|") >= 3
+
+
+def _is_mysql_footer_line(line: str) -> bool:
+    stripped = line.strip()
+    return " row in set" in stripped or " rows in set" in stripped
+
+
+def _is_markdown_row(line: str) -> bool:
+    stripped = line.strip()
+    return stripped.startswith("|") and stripped.endswith("|") and stripped.count("|") >= 3
+
+
+def _is_markdown_separator(line: str) -> bool:
+    if not _is_markdown_row(line):
+        return False
+    cells = [cell.strip().replace(" ", "") for cell in line.strip().strip("|").split("|")]
+    if len(cells) < 2:
+        return False
+    for cell in cells:
+        if not re.fullmatch(r":?-{3,}:?", cell):
+            return False
+    return True
+
+
+def _looks_like_traceback_line(line: str) -> bool:
+    stripped = line.lstrip()
+    return stripped.startswith("Traceback ") or stripped.startswith('File "')
+
+
+def _looks_like_log_line(line: str) -> bool:
+    stripped = line.lstrip()
+    return stripped.startswith(("INFO ", "DEBUG ", "TRACE ", "WARN ", "ERROR "))
+
+
+def _looks_like_path_location_output(lines: list[str]) -> bool:
+    matches = sum(1 for line in lines if _looks_like_path_location_line(line))
+    return matches >= 2 and matches * 2 >= len(lines)
+
+
+def _looks_like_path_location_line(line: str) -> bool:
+    match = _PATH_LOCATION_RE.match(line)
+    if match is None:
+        return False
+    return _looks_like_path(match.group(1))
+
+
+def _looks_like_path(value: str) -> bool:
+    return (
+        "/" in value
+        or "\\" in value
+        or "." in value.rsplit("/", 1)[-1].rsplit("\\", 1)[-1]
+        or value.startswith(("~", "/"))
+    )

codetool_shell/filters/table/reducer.py

@@ -0,0 +1,57 @@
+"""Reduce long structured tables while preserving diagnostic rows."""
+
+from __future__ import annotations
+
+from ..text import join_preserving_final_newline, score, split_preserving_final_newline
+from .detector import StructuredTable, parse_structured_table
+from .summary import is_interesting_row
+
+_HEAD_ROWS = 3
+_TAIL_ROWS = 3
+
+
+def compress_table_output(text: str) -> str:
+    """Compress clear long table output, otherwise return ``text`` unchanged."""
+
+    lines, final_newline = split_preserving_final_newline(text)
+    parsed = parse_structured_table(lines)
+    if parsed is None:
+        return text
+
+    candidate_lines = _reduce_table(parsed)
+    candidate = join_preserving_final_newline(candidate_lines, final_newline)
+    if score(candidate) < score(text):
+        return candidate
+    return text
+
+
+def _reduce_table(table: StructuredTable) -> list[str]:
+    selected_indices = _select_row_indices(table.rows)
+    selected = [*table.header_lines]
+    cursor = 0
+
+    for index in selected_indices:
+        omitted = index - cursor
+        if omitted > 0:
+            selected.append(_omitted_line(omitted))
+        selected.append(table.rows[index])
+        cursor = index + 1
+
+    if cursor < len(table.rows):
+        selected.append(_omitted_line(len(table.rows) - cursor))
+
+    selected.extend(table.footer_lines)
+    return selected
+
+
+def _select_row_indices(rows: tuple[str, ...]) -> list[int]:
+    total = len(rows)
+    selected = set(range(min(_HEAD_ROWS, total)))
+    selected.update(range(max(_HEAD_ROWS, total - _TAIL_ROWS), total))
+    selected.update(index for index, row in enumerate(rows) if is_interesting_row(row))
+    return sorted(selected)
+
+
+def _omitted_line(count: int) -> str:
+    plural = "" if count == 1 else "s"
+    return f"… {count} table row{plural} omitted"

codetool_shell/filters/table/summary.py

@@ -0,0 +1,37 @@
+"""Row importance helpers for structured table compression."""
+
+from __future__ import annotations
+
+import re
+
+_ALERT_RE = re.compile(
+    r"\b(?:error|errors|warn|warning|warnings|fail|failed|failure|fatal|critical|exception|traceback)\b",
+    re.IGNORECASE,
+)
+_URL_RE = re.compile(r"\b[A-Za-z][A-Za-z0-9+.-]*://\S+")
+_PATH_RE = re.compile(
+    r"(^|[\s|])(?:\.{0,2}/|/|~/|[A-Za-z]:[\\/]|[A-Za-z0-9_.@+-]+/[A-Za-z0-9_.@+/\-]+)"
+)
+_UUID_RE = re.compile(
+    r"\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b"
+)
+_LONG_HEX_RE = re.compile(r"\b[0-9a-fA-F]{12,}\b")
+_ISSUE_ID_RE = re.compile(r"\b[A-Z]{2,}-\d{2,}\b")
+_NAMED_ID_RE = re.compile(r"\b(?:id|uuid|hash|sha)[=: ]+[A-Za-z0-9_-]{8,}\b", re.IGNORECASE)
+
+
+def is_interesting_row(row: str) -> bool:
+    """Return whether a row should be preserved even from the middle."""
+
+    return any(
+        pattern.search(row)
+        for pattern in (
+            _ALERT_RE,
+            _URL_RE,
+            _PATH_RE,
+            _UUID_RE,
+            _LONG_HEX_RE,
+            _ISSUE_ID_RE,
+            _NAMED_ID_RE,
+        )
+    )

codetool_shell/filters/test_runner/__init__.py

@@ -0,0 +1,7 @@
+"""Test-runner shellion filter."""
+
+from __future__ import annotations
+
+from .reducer import compress_test_runner_output
+
+__all__ = ["compress_test_runner_output"]

codetool_shell/filters/test_runner/ansi.py

@@ -0,0 +1,80 @@
+"""ANSI/control decoration stripping for test-runner output."""
+
+from __future__ import annotations
+
+ESC = "\x1b"
+
+
+def strip_ansi_control_sequences(text: str) -> str:
+    """Remove known terminal decorations while preserving unknown escapes."""
+
+    output: list[str] = []
+    index = 0
+    length = len(text)
+
+    while index < length:
+        char = text[index]
+
+        if char == ESC:
+            sequence_end = _known_escape_sequence_end(text, index)
+            if sequence_end is not None:
+                index = sequence_end
+                continue
+            output.append(char)
+            index += 1
+            continue
+
+        if _is_removable_control_char(char):
+            index += 1
+            continue
+
+        output.append(char)
+        index += 1
+
+    return "".join(output)
+
+
+def _known_escape_sequence_end(text: str, index: int) -> int | None:
+    csi_end = _known_csi_sequence_end(text, index)
+    if csi_end is not None:
+        return csi_end
+
+    if index + 2 < len(text) and text[index + 1] in {"(", ")", "*", "+"}:
+        final = ord(text[index + 2])
+        if 0x20 <= final <= 0x7E:
+            return index + 3
+
+    return None
+
+
+def _known_csi_sequence_end(text: str, index: int) -> int | None:
+    start = index + 2
+    if start > len(text) or text[index + 1 : start] != "[":
+        return None
+
+    cursor = start
+    while cursor < len(text):
+        char = text[cursor]
+        codepoint = ord(char)
+        if 0x40 <= codepoint <= 0x7E:
+            params = text[start:cursor]
+            if _should_strip_csi(params, char):
+                return cursor + 1
+            return None
+        if not 0x20 <= codepoint <= 0x3F:
+            return None
+        cursor += 1
+
+    return None
+
+
+def _should_strip_csi(params: str, final: str) -> bool:
+    if final in {"m", "K", "J", "A", "B", "C", "D", "E", "F", "G"}:
+        return True
+    return final in {"h", "l"} and params.startswith("?25")
+
+
+def _is_removable_control_char(char: str) -> bool:
+    return char not in {"\n", "\t"} and (
+        "\x00" <= char <= "\x08" or "\x0b" <= char <= "\x1f" or char == "\x7f"
+    )