codetool-shell 0.1.1__py3-none-win_amd64.whl

codetool_shell/filters/rg.py

@@ -0,0 +1,250 @@
+"""Compression for ripgrep/path-location output."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from .text import (
+    choose_smaller_lines,
+    join_preserving_final_newline,
+    split_preserving_final_newline,
+)
+from .tree import TreeRow, format_tree
+
+
+def compress_rg_output(text: str) -> str:
+    """Compress rg-like path-location output by grouping repeated paths."""
+
+    lines, final_newline = split_preserving_final_newline(text)
+    output: list[str] = []
+    i = 0
+
+    while i < len(lines):
+        direct_block = _collect_direct_block(lines, i)
+        if direct_block is not None:
+            block_lines, block_items, i = direct_block
+            output.extend(_compress_rg_block(block_lines, block_items))
+            continue
+
+        heading_block = _collect_heading_block(lines, i)
+        if heading_block is not None:
+            block_lines, block_items, i = heading_block
+            output.extend(_compress_rg_block(block_lines, block_items))
+            continue
+
+        output.append(lines[i])
+        i += 1
+
+    return join_preserving_final_newline(output, final_newline)
+
+
+@dataclass(frozen=True)
+class _RgEntry:
+    path: str
+    line: str
+    column: str | None
+    text: str
+    separator: str
+
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
+_RG_MATCH_RE = re.compile(r"^(.+?):([1-9]\d*)(?::([1-9]\d*))?:(.*)$")
+_RG_CONTEXT_RE = re.compile(r"^(.+?)-([1-9]\d*)-(.*)$")
+_HEADING_MATCH_RE = re.compile(r"^([1-9]\d*)(?::([1-9]\d*))?:(.*)$")
+_HEADING_CONTEXT_RE = re.compile(r"^([1-9]\d*)-(.*)$")
+_DIAGNOSTIC_TEXT_RE = re.compile(
+    r"^\s*(?:error|warning|note|help):|\b(?:error|warning)\s+TS\d+:",
+    re.IGNORECASE,
+)
+
+
+def _strip_ansi(line: str) -> str:
+    return _ANSI_RE.sub("", line)
+
+
+def _collect_direct_block(
+    lines: list[str], start: int
+) -> tuple[list[str], list[_RgEntry | None], int] | None:
+    parsed = _parse_path_location_line(lines[start])
+    if parsed is None:
+        return None
+
+    block_lines = [lines[start]]
+    block_items: list[_RgEntry | None] = [parsed]
+    i = start + 1
+    while i < len(lines):
+        parsed = _parse_path_location_line(lines[i])
+        if parsed is not None:
+            block_lines.append(lines[i])
+            block_items.append(parsed)
+            i += 1
+            continue
+        if _is_context_separator(lines[i]) and _next_line_is_direct_entry(lines, i):
+            block_lines.append(lines[i])
+            block_items.append(None)
+            i += 1
+            continue
+        break
+
+    return block_lines, block_items, i
+
+
+def _collect_heading_block(
+    lines: list[str], start: int
+) -> tuple[list[str], list[_RgEntry | None], int] | None:
+    clean_header = _strip_ansi(lines[start]).strip()
+    if not _looks_like_rg_path(clean_header):
+        return None
+    if start + 1 >= len(lines):
+        return None
+    if _parse_heading_entry_line(lines[start + 1], clean_header) is None:
+        return None
+
+    block_lines: list[str] = []
+    block_items: list[_RgEntry | None] = []
+    i = start
+    header_count = 0
+
+    while i < len(lines):
+        path = _strip_ansi(lines[i]).strip()
+        if not _looks_like_rg_path(path):
+            break
+        if i + 1 >= len(lines) or _parse_heading_entry_line(lines[i + 1], path) is None:
+            break
+
+        header_count += 1
+        block_lines.append(lines[i])
+        i += 1
+
+        while i < len(lines):
+            parsed = _parse_heading_entry_line(lines[i], path)
+            if parsed is not None:
+                block_lines.append(lines[i])
+                block_items.append(parsed)
+                i += 1
+                continue
+            if _is_context_separator(lines[i]) and _next_line_is_heading_entry_or_path(
+                lines, i, path
+            ):
+                block_lines.append(lines[i])
+                block_items.append(None)
+                i += 1
+                continue
+            break
+
+    entries = [item for item in block_items if item is not None]
+    if header_count == 0 or len(entries) < 2:
+        return None
+    return block_lines, block_items, i
+
+
+def _parse_path_location_line(line: str) -> _RgEntry | None:
+    clean = _strip_ansi(line)
+    match = _RG_MATCH_RE.match(clean)
+    if match is not None:
+        path, line_number, column, snippet = match.groups()
+        if _looks_like_rg_path(path):
+            return _RgEntry(path, line_number, column, snippet, ":")
+
+    context = _RG_CONTEXT_RE.match(clean)
+    if context is None:
+        return None
+    path, line_number, snippet = context.groups()
+    if not _looks_like_rg_path(path):
+        return None
+    return _RgEntry(path, line_number, None, snippet, "-")
+
+
+def _parse_heading_entry_line(line: str, path: str) -> _RgEntry | None:
+    clean = _strip_ansi(line)
+    match = _HEADING_MATCH_RE.match(clean)
+    if match is not None:
+        line_number, column, snippet = match.groups()
+        return _RgEntry(path, line_number, column, snippet, ":")
+
+    context = _HEADING_CONTEXT_RE.match(clean)
+    if context is None:
+        return None
+    line_number, snippet = context.groups()
+    return _RgEntry(path, line_number, None, snippet, "-")
+
+
+def _is_context_separator(line: str) -> bool:
+    return _strip_ansi(line).strip() == "--"
+
+
+def _next_line_is_direct_entry(lines: list[str], index: int) -> bool:
+    return index + 1 < len(lines) and _parse_path_location_line(lines[index + 1]) is not None
+
+
+def _next_line_is_heading_entry_or_path(lines: list[str], index: int, path: str) -> bool:
+    if index + 1 >= len(lines):
+        return False
+    if _parse_heading_entry_line(lines[index + 1], path) is not None:
+        return True
+    next_clean = _strip_ansi(lines[index + 1]).strip()
+    return (
+        _looks_like_rg_path(next_clean)
+        and index + 2 < len(lines)
+        and _parse_heading_entry_line(lines[index + 2], next_clean) is not None
+    )
+
+
+def _looks_like_rg_path(path: str) -> bool:
+    path = path.strip()
+    if not path or path.isdigit() or path[0].isspace():
+        return False
+    if len(path) > 240 or "://" in path:
+        return False
+    if any(ch.isspace() for ch in path):
+        return False
+    if path[0] in "-+|":
+        return False
+    if any(ch in path for ch in "{}[]\"',"):
+        return False
+    return (
+        "/" in path
+        or "\\" in path
+        or "." in path
+        or path.startswith(("~", "/"))
+    )
+
+
+def _compress_rg_block(block_lines: list[str], items: list[_RgEntry | None]) -> list[str]:
+    entries = [item for item in items if item is not None]
+    if len(entries) < 2 or _looks_like_diagnostic_block(entries):
+        return block_lines
+
+    grouped: list[tuple[str, list[str]]] = []
+    for item in items:
+        if item is None:
+            if grouped:
+                grouped[-1][1].append("--")
+            continue
+
+        entry = _format_entry(item)
+        for path, path_entries in grouped:
+            if path == item.path:
+                path_entries.append(entry)
+                break
+        else:
+            grouped.append((item.path, [entry]))
+
+    rows = [TreeRow(path, children=tuple(entries)) for path, entries in grouped]
+    candidate = format_tree(rows).splitlines()
+    return choose_smaller_lines(block_lines, candidate)
+
+
+def _format_entry(entry: _RgEntry) -> str:
+    if entry.separator == "-":
+        return f"{entry.line}-{entry.text}"
+    location = entry.line if entry.column is None else f"{entry.line}:{entry.column}"
+    return f"{location}:{entry.text}"
+
+
+def _looks_like_diagnostic_block(entries: list[_RgEntry]) -> bool:
+    diagnostic_count = sum(
+        1 for entry in entries if _DIAGNOSTIC_TEXT_RE.search(entry.text) is not None
+    )
+    return diagnostic_count >= 2 or diagnostic_count == len(entries)

codetool_shell/filters/system_output/__init__.py

@@ -0,0 +1,7 @@
+"""System command shellion."""
+
+from __future__ import annotations
+
+from .reducer import compress_system_output
+
+__all__ = ["compress_system_output"]