codetool-shell 0.1.1__py3-none-win_amd64.whl

codetool_shell/filters/system_output/detector.py

@@ -0,0 +1,600 @@
+"""Conservative detectors for common system command output."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class EnvVar:
+    key: str
+    value: str
+
+
+@dataclass(frozen=True)
+class EnvOutput:
+    vars: tuple[EnvVar, ...]
+
+
+@dataclass(frozen=True)
+class DfRow:
+    line: str
+    usage: int
+    mount: str
+
+
+@dataclass(frozen=True)
+class DfOutput:
+    header: str
+    rows: tuple[DfRow, ...]
+
+
+@dataclass(frozen=True)
+class DuRow:
+    line: str
+    size: float
+    path: str
+    is_total: bool
+
+
+@dataclass(frozen=True)
+class DuOutput:
+    rows: tuple[DuRow, ...]
+
+
+@dataclass(frozen=True)
+class PsRow:
+    line: str
+    cpu: float | None
+    mem: float | None
+    command: str
+
+
+@dataclass(frozen=True)
+class PsOutput:
+    header: str
+    rows: tuple[PsRow, ...]
+
+
+@dataclass(frozen=True)
+class PingOutput:
+    lines: tuple[str, ...]
+    reply_indices: tuple[int, ...]
+    event_indices: tuple[int, ...]
+    summary_indices: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class SystemctlStatusOutput:
+    lines: tuple[str, ...]
+    core_indices: tuple[int, ...]
+    alert_indices: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class WcRow:
+    line: str
+    numbers: tuple[int, ...]
+    path: str
+    is_total: bool
+
+
+@dataclass(frozen=True)
+class WcOutput:
+    rows: tuple[WcRow, ...]
+    total_index: int
+
+
+@dataclass(frozen=True)
+class StatBlock:
+    file: str
+    size: str
+    mode: str
+    owner: str
+    group: str
+    modify: str
+
+
+_MIN_ENV_VARS = 12
+_MIN_DF_ROWS = 8
+_MIN_DU_ROWS = 12
+_MIN_PS_ROWS = 10
+_MIN_PING_REPLIES = 8
+_MIN_SYSTEMCTL_LINES = 10
+_MIN_WC_FILE_ROWS = 8
+_MIN_STAT_BLOCKS = 3
+
+_ENV_ANCHOR_KEYS = frozenset(
+    {
+        "HOME",
+        "PATH",
+        "PWD",
+        "SHELL",
+        "USER",
+        "LOGNAME",
+        "TERM",
+        "LANG",
+        "VIRTUAL_ENV",
+    }
+)
+
+_PS_COMMAND_HEADERS = frozenset({"COMMAND", "CMD", "ARGS"})
+_SIZE_UNITS = {
+    "": 1.0,
+    "B": 1.0,
+    "K": 1024.0,
+    "KB": 1024.0,
+    "KI": 1024.0,
+    "KIB": 1024.0,
+    "M": 1024.0**2,
+    "MB": 1024.0**2,
+    "MI": 1024.0**2,
+    "MIB": 1024.0**2,
+    "G": 1024.0**3,
+    "GB": 1024.0**3,
+    "GI": 1024.0**3,
+    "GIB": 1024.0**3,
+    "T": 1024.0**4,
+    "TB": 1024.0**4,
+    "TI": 1024.0**4,
+    "TIB": 1024.0**4,
+    "P": 1024.0**5,
+    "PB": 1024.0**5,
+    "PI": 1024.0**5,
+    "PIB": 1024.0**5,
+}
+
+
+def parse_env_output(lines: list[str]) -> EnvOutput | None:
+    if len(lines) < _MIN_ENV_VARS or any(not line for line in lines):
+        return None
+
+    vars_: list[EnvVar] = []
+    uppercase_count = 0
+    for line in lines:
+        parsed = _parse_env_line(line)
+        if parsed is None:
+            return None
+        vars_.append(parsed)
+        if parsed.key.upper() == parsed.key:
+            uppercase_count += 1
+
+    keys = {var.key for var in vars_}
+    if not keys.intersection(_ENV_ANCHOR_KEYS) and uppercase_count * 2 < len(vars_):
+        return None
+    return EnvOutput(tuple(vars_))
+
+
+def parse_df_output(lines: list[str]) -> DfOutput | None:
+    if len(lines) < _MIN_DF_ROWS + 1 or not lines:
+        return None
+
+    header = lines[0]
+    header_tokens = header.split()
+    if not header_tokens or header_tokens[0] != "Filesystem":
+        return None
+    use_index = _find_use_percent_index(header_tokens)
+    if use_index is None or "Mounted" not in header_tokens:
+        return None
+
+    rows: list[DfRow] = []
+    for line in lines[1:]:
+        if not line.strip():
+            return None
+        row = _parse_df_row(line, use_index)
+        if row is None:
+            return None
+        rows.append(row)
+
+    if len(rows) < _MIN_DF_ROWS:
+        return None
+    return DfOutput(header, tuple(rows))
+
+
+def parse_du_output(lines: list[str]) -> DuOutput | None:
+    if len(lines) < _MIN_DU_ROWS or any(not line.strip() for line in lines):
+        return None
+
+    rows: list[DuRow] = []
+    path_like = 0
+    unitless = 0
+    file_like = 0
+    for line in lines:
+        row = _parse_du_row(line)
+        if row is None:
+            return None
+        rows.append(row)
+        if row.is_total or _looks_like_path(row.path):
+            path_like += 1
+        if _is_unitless_size_token(line.split(maxsplit=1)[0]):
+            unitless += 1
+        if not row.is_total and "." in row.path.rsplit("/", 1)[-1]:
+            file_like += 1
+
+    if path_like * 2 < len(rows):
+        return None
+    non_total = len(rows) - sum(row.is_total for row in rows)
+    if unitless == len(rows) and non_total > 0 and file_like * 2 >= non_total:
+        return None
+    return DuOutput(tuple(rows))
+
+
+def parse_ps_output(lines: list[str]) -> PsOutput | None:
+    if len(lines) < _MIN_PS_ROWS + 1:
+        return None
+
+    header = lines[0]
+    header_tokens = header.split()
+    if "PID" not in header_tokens:
+        return None
+    command_index = _find_command_index(header_tokens)
+    if command_index is None:
+        return None
+    cpu_index = _find_optional_index(header_tokens, "%CPU")
+    mem_index = _find_optional_index(header_tokens, "%MEM")
+    if cpu_index is None and mem_index is None:
+        return None
+
+    pid_index = header_tokens.index("PID")
+    rows: list[PsRow] = []
+    for line in lines[1:]:
+        if not line.strip():
+            return None
+        parts = line.split(maxsplit=len(header_tokens) - 1)
+        if len(parts) < len(header_tokens) or not parts[pid_index].isdigit():
+            return None
+        cpu = _parse_float_at(parts, cpu_index)
+        mem = _parse_float_at(parts, mem_index)
+        command = parts[command_index]
+        rows.append(PsRow(line=line, cpu=cpu, mem=mem, command=command))
+
+    if len(rows) < _MIN_PS_ROWS:
+        return None
+    return PsOutput(header, tuple(rows))
+
+
+def parse_ping_output(lines: list[str]) -> PingOutput | None:
+    if not lines or not lines[0].startswith("PING "):
+        return None
+
+    reply_indices: list[int] = []
+    event_indices: list[int] = []
+    summary_indices: list[int] = []
+    for index, line in enumerate(lines):
+        lower = line.lower()
+        if index == 0:
+            continue
+        if _is_ping_reply(lower):
+            reply_indices.append(index)
+        elif _is_ping_summary_line(lower):
+            summary_indices.append(index)
+        elif _is_ping_event_line(lower):
+            event_indices.append(index)
+
+    if len(reply_indices) < _MIN_PING_REPLIES and len(lines) < _MIN_PING_REPLIES + 4:
+        return None
+    if not summary_indices and not event_indices:
+        return None
+    return PingOutput(
+        lines=tuple(lines),
+        reply_indices=tuple(reply_indices),
+        event_indices=tuple(event_indices),
+        summary_indices=tuple(summary_indices),
+    )
+
+
+def parse_systemctl_status_output(lines: list[str]) -> SystemctlStatusOutput | None:
+    if len(lines) < _MIN_SYSTEMCTL_LINES:
+        return None
+
+    stripped = [line.strip() for line in lines]
+    has_unit_header = stripped[0].startswith("● ") or ".service" in stripped[0]
+    has_loaded = any(line.startswith("Loaded:") for line in stripped)
+    has_active = any(line.startswith("Active:") for line in stripped)
+    if not (has_unit_header and has_loaded and has_active):
+        return None
+
+    core_indices: list[int] = [0]
+    alert_indices: list[int] = []
+    for index, line in enumerate(stripped):
+        if index == 0:
+            continue
+        if line.startswith(("Loaded:", "Active:", "Main PID:")):
+            core_indices.append(index)
+        if _contains_alert(line):
+            alert_indices.append(index)
+
+    if len(core_indices) < 3:
+        return None
+    return SystemctlStatusOutput(
+        lines=tuple(lines),
+        core_indices=tuple(_unique_sorted(core_indices)),
+        alert_indices=tuple(_unique_sorted(alert_indices)),
+    )
+
+
+def parse_wc_output(lines: list[str]) -> WcOutput | None:
+    if len(lines) < _MIN_WC_FILE_ROWS + 1 or any(not line.strip() for line in lines):
+        return None
+
+    rows: list[WcRow] = []
+    numeric_columns: int | None = None
+    total_index: int | None = None
+    for index, line in enumerate(lines):
+        row = _parse_wc_row(line)
+        if row is None:
+            return None
+        if numeric_columns is None:
+            numeric_columns = len(row.numbers)
+        elif len(row.numbers) != numeric_columns:
+            return None
+        if row.is_total:
+            total_index = index
+        rows.append(row)
+
+    if total_index is None:
+        return None
+    file_rows = [row for row in rows if not row.is_total]
+    if len(file_rows) < _MIN_WC_FILE_ROWS:
+        return None
+    if numeric_columns == 1 and sum(_looks_like_file_path(row.path) for row in file_rows) * 2 < len(file_rows):
+        return None
+    return WcOutput(tuple(rows), total_index)
+
+
+def parse_stat_blocks(lines: list[str]) -> tuple[StatBlock, ...] | None:
+    if len(lines) < _MIN_STAT_BLOCKS * 5:
+        return None
+
+    blocks: list[list[str]] = []
+    current: list[str] = []
+    for line in lines:
+        if line.strip().startswith("File:"):
+            if current:
+                blocks.append(current)
+            current = [line]
+        elif current:
+            current.append(line)
+        elif line.strip():
+            return None
+    if current:
+        blocks.append(current)
+
+    if len(blocks) < _MIN_STAT_BLOCKS:
+        return None
+
+    parsed: list[StatBlock] = []
+    for block in blocks:
+        stat_block = _parse_stat_block(block)
+        if stat_block is None:
+            return None
+        parsed.append(stat_block)
+    return tuple(parsed)
+
+
+def _parse_env_line(line: str) -> EnvVar | None:
+    if "=" not in line or line.startswith(("export ", "declare ")):
+        return None
+    key, value = line.split("=", 1)
+    if not key or not (key[0].isalpha() or key[0] == "_"):
+        return None
+    if any(not (char.isalnum() or char == "_") for char in key):
+        return None
+    return EnvVar(key, value)
+
+
+def _find_use_percent_index(tokens: list[str]) -> int | None:
+    for index, token in enumerate(tokens):
+        if token.endswith("Use%"):
+            return index
+    return None
+
+
+def _parse_df_row(line: str, use_index: int) -> DfRow | None:
+    tokens = line.split()
+    if len(tokens) <= use_index + 1:
+        return None
+    usage_token = tokens[use_index]
+    if not usage_token.endswith("%") or not usage_token[:-1].isdigit():
+        return None
+    mount = " ".join(tokens[use_index + 1 :])
+    if not mount:
+        return None
+    return DfRow(line=line, usage=int(usage_token[:-1]), mount=mount)
+
+
+def _parse_du_row(line: str) -> DuRow | None:
+    parts = line.split(maxsplit=1)
+    if len(parts) != 2:
+        return None
+    size = _parse_size(parts[0])
+    if size is None:
+        return None
+    path = parts[1].strip()
+    if not path:
+        return None
+    return DuRow(line=line, size=size, path=path, is_total=path == "total")
+
+
+def _parse_size(token: str) -> float | None:
+    number = ""
+    unit = ""
+    for char in token:
+        if char.isdigit() or char == ".":
+            number += char
+        else:
+            unit += char
+    if not number or number.count(".") > 1:
+        return None
+    unit = unit.upper()
+    multiplier = _SIZE_UNITS.get(unit)
+    if multiplier is None:
+        return None
+    try:
+        return float(number) * multiplier
+    except ValueError:
+        return None
+
+
+def _is_unitless_size_token(token: str) -> bool:
+    return token.isdigit()
+
+
+def _find_command_index(tokens: list[str]) -> int | None:
+    for index, token in enumerate(tokens):
+        if token in _PS_COMMAND_HEADERS:
+            return index
+    return None
+
+
+def _find_optional_index(tokens: list[str], value: str) -> int | None:
+    try:
+        return tokens.index(value)
+    except ValueError:
+        return None
+
+
+def _parse_float_at(parts: list[str], index: int | None) -> float | None:
+    if index is None or index >= len(parts):
+        return None
+    try:
+        return float(parts[index])
+    except ValueError:
+        return None
+
+
+def _is_ping_reply(lower: str) -> bool:
+    return "bytes from" in lower and ("icmp_seq" in lower or "icmp_seq=" in lower)
+
+
+def _is_ping_summary_line(lower: str) -> bool:
+    return (
+        lower.startswith("--- ")
+        or "packets transmitted" in lower
+        or lower.startswith("rtt ")
+        or lower.startswith("round-trip ")
+    )
+
+
+def _is_ping_event_line(lower: str) -> bool:
+    return any(
+        marker in lower
+        for marker in (
+            "timeout",
+            "unreachable",
+            "unknown host",
+            "name or service",
+            "temporary failure",
+            "packet loss",
+            "error",
+        )
+    )
+
+
+def _contains_alert(line: str) -> bool:
+    lower = line.lower()
+    return any(
+        word in lower
+        for word in (
+            "failed",
+            "failure",
+            "error",
+            "warning",
+            "warn",
+            "critical",
+            "denied",
+            "refused",
+            "timeout",
+        )
+    )
+
+
+def _parse_wc_row(line: str) -> WcRow | None:
+    tokens = line.split()
+    if len(tokens) < 2:
+        return None
+    numbers: list[int] = []
+    cursor = 0
+    for token in tokens:
+        if token.isdigit():
+            numbers.append(int(token))
+            cursor += 1
+        else:
+            break
+    if not numbers or cursor >= len(tokens):
+        return None
+    path = " ".join(tokens[cursor:])
+    return WcRow(line=line, numbers=tuple(numbers), path=path, is_total=path == "total")
+
+
+def _parse_stat_block(lines: list[str]) -> StatBlock | None:
+    file_name = _value_after_label(lines[0], "File:")
+    size = mode = owner = group = modify = None
+    for line in lines[1:]:
+        stripped = line.strip()
+        if stripped.startswith("Size:"):
+            size = _field_between(stripped, "Size:", "Blocks:") or _value_after_label(stripped, "Size:")
+        elif stripped.startswith("Access: (") and "Uid:" in stripped and "Gid:" in stripped:
+            mode = _paren_after(stripped, "Access:")
+            owner = _paren_after(stripped, "Uid:")
+            group = _paren_after(stripped, "Gid:")
+        elif stripped.startswith("Modify:"):
+            modify = _value_after_label(stripped, "Modify:")
+
+    if not all((file_name, size, mode, owner, group, modify)):
+        return None
+    return StatBlock(
+        file=file_name.strip(),
+        size=size.strip(),
+        mode=_compact_owner(mode),
+        owner=_compact_owner(owner),
+        group=_compact_owner(group),
+        modify=modify.strip(),
+    )
+
+
+def _value_after_label(line: str, label: str) -> str:
+    if label not in line:
+        return ""
+    return line.split(label, 1)[1].strip()
+
+
+def _field_between(line: str, start: str, end: str) -> str:
+    if start not in line or end not in line:
+        return ""
+    return line.split(start, 1)[1].split(end, 1)[0].strip()
+
+
+def _paren_after(line: str, label: str) -> str:
+    start = line.find(label)
+    if start < 0:
+        return ""
+    open_index = line.find("(", start)
+    close_index = line.find(")", open_index + 1)
+    if open_index < 0 or close_index < 0:
+        return ""
+    return line[open_index + 1 : close_index].strip()
+
+
+def _compact_owner(value: str | None) -> str:
+    if not value:
+        return ""
+    return "/".join(part.strip() for part in value.split("/"))
+
+
+def _looks_like_path(path: str) -> bool:
+    return (
+        path == "total"
+        or path.startswith(("/", "./", "../", "~"))
+        or "/" in path
+        or path in {".", ".."}
+    )
+
+
+def _looks_like_file_path(path: str) -> bool:
+    name = path.rsplit("/", 1)[-1]
+    return _looks_like_path(path) or "." in name
+
+
+def _unique_sorted(values: list[int]) -> list[int]:
+    return sorted(set(values))