python-code-quality 0.1.15__py3-none-any.whl → 0.2.1__py3-none-any.whl

py_cq/parsers/interrogateparser.py

@@ -7,52 +7,288 @@ per-file docstring coverage on stdout::
     | TOTAL       |  5 |  2 |  3 |  60.0% |
 
 The parser extracts per-file coverage and the TOTAL row, storing the TOTAL
-as the ``doc_coverage`` metric (0.0–1.0).
+as the ``doc_coverage`` metric (0.0-1.0).
 """
 
+import ast
 import re
+import tomllib
+from pathlib import Path
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+from py_cq.parsers.common import (
+    extract_first_issue,
+    format_issue_header,
+    format_source_context,
+)
 
-_ROW_RE = re.compile(r"^\|\s+(.+?)\s+\|\s+(\d+)\s+\|\s+(\d+)\s+\|\s+\d+\s+\|\s+(\d+(?:\.\d+)?)%\s*\|")
+_SKIP_PARAMS = {"self", "cls"}
+
+
+def _format_missing_docstring(file_str: str, line: int, code: str, message: str) -> str:
+    base = format_issue_header(file_str, line, code, message) + format_source_context(
+        file_str, line
+    )
+
+    if code == "D100":
+        return base + "\n\nInsert a module-level docstring as the very first statement in the file."
+
+    try:
+        source = Path(file_str).read_text(encoding="utf-8")
+        tree = ast.parse(source)
+    except (OSError, SyntaxError):
+        return base + "\n\nInsert a docstring as the first statement in the body."
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.lineno == line:
+            insert_line = node.body[0].lineno
+            return (
+                base
+                + f"\n\nInsert a docstring on line {insert_line} (first line of the class body)."
+                + "\n\nA good class docstring describes the class purpose in one sentence."
+            )
+        if (
+            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and node.lineno == line
+        ):
+            insert_line = node.body[0].lineno
+            params = [a.arg for a in node.args.args if a.arg not in _SKIP_PARAMS]
+            returns = ast.unparse(node.returns) if node.returns else None
+
+            hint = f"\n\nInsert a docstring on line {insert_line} (first line of the function body)."
+            hint += "\n\nA good one-line docstring describes what the function does (not how)."
+
+            indent = "    "
+            if returns:
+                hint += f' Return annotation is `{returns}` - start the docstring with a verb like "Return ...".'
+                hint += f'\n\nExample:\n```python\n{indent}"""Return the <value> for <reason>."""\n```'
+            else:
+                hint += f'\n\nExample:\n```python\n{indent}"""Do <action> and return <result>."""\n```'
+
+            if params:
+                hint += f"\n\nDocument non-obvious parameters: {', '.join(f'`{p}`' for p in params)}."
+
+            return base + hint
+
+    return base + "\n\nInsert a docstring as the first statement in the body."
+
+_ROW_RE = re.compile(
+    r"^\|\s+(.+?)\s+\|\s+(\d+)\s+\|\s+(\d+)\s+\|\s+\d+\s+\|\s+(\d+(?:\.\d+)?)%\s*\|"
+)
+_CONTEXT_PATH_RE = re.compile(r'interrogate\s+"([^"]+)"')
+_COVERAGE_FOR_RE = re.compile(r"Coverage for\s+(.+?)[\s=]*$")
+
+
+def _load_interrogate_cfg(context_path: str) -> dict:
+    """Read [tool.interrogate] from the nearest pyproject.toml."""
+    p = Path(context_path).resolve()
+    for candidate in [p, *p.parents]:
+        pyproject = (candidate if candidate.is_dir() else candidate.parent) / "pyproject.toml"
+        if pyproject.exists():
+            try:
+                data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+                return data.get("tool", {}).get("interrogate", {})
+            except Exception:
+                return {}
+    return {}
+
+
+def _skip_node(name: str, cfg: dict) -> bool:
+    """Return True if interrogate would skip this name given cfg."""
+    is_magic = name.startswith("__") and name.endswith("__")
+    is_private = name.startswith("__") and not name.endswith("__")
+    is_semiprivate = name.startswith("_") and not name.startswith("__")
+    if name == "__init__" and cfg.get("ignore-init-method"):
+        return True
+    if is_magic and cfg.get("ignore-magic"):
+        return True
+    if is_private and cfg.get("ignore-private"):
+        return True
+    if is_semiprivate and cfg.get("ignore-semiprivate"):
+        return True
+    return False
+
+
+def _missing_docstrings(file_path: Path, cfg: dict | None = None) -> list[tuple[int, str, str]]:
+    """Return (line, kind, source_line) for each node missing a docstring.
+
+    kind is 'module', 'def', or 'class'. source_line is the verbatim text of
+    the def/class line (for searching), or the first non-empty source line for
+    the module.
+    """
+    try:
+        source = file_path.read_text(encoding="utf-8")
+        tree = ast.parse(source, filename=str(file_path))
+    except (OSError, SyntaxError):
+        return []
+    src_lines = source.splitlines()
+
+    def src_line(lineno: int) -> str:
+        """Return the stripped content of the source line at the given line number."""
+        return src_lines[lineno - 1].strip() if 0 < lineno <= len(src_lines) else ""
+
+    def first_code_line() -> str:
+        """Return the first non-empty, non-comment line of the source."""
+        for ln in src_lines:
+            stripped = ln.strip()
+            if stripped and not stripped.startswith("#"):
+                return stripped
+        return ""
+
+    effective_cfg = cfg or {}
+    results = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Module):
+            if not ast.get_docstring(node):
+                results.append((0, "module", first_code_line()))
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if not ast.get_docstring(node) and not _skip_node(node.name, effective_cfg):
+                results.append((node.lineno, "def", src_line(node.lineno)))
+        elif isinstance(node, ast.ClassDef):
+            if not ast.get_docstring(node) and not _skip_node(node.name, effective_cfg):
+                results.append((node.lineno, "class", src_line(node.lineno)))
+    results.sort(key=lambda x: x[0])
+    return results
+
+
+def _is_file_empty(path: Path | None) -> bool:
+    """Check if the file is empty."""
+    if path is None:
+        return False
+    try:
+        return not path.read_text(encoding="utf-8").strip()
+    except OSError:
+        return False
+
+
+def _resolve(context_path: str, rel_file: str) -> Path | None:
+    """Return the first existing Path for rel_file, trying context_path then cwd."""
+    via_context = Path(context_path) / rel_file
+    if via_context.exists():
+        return via_context
+    # When context_path is a file, interrogate reports only the basename.
+    # Try the parent directory so "dig.py" resolves against "D:/.../dig.py".
+    via_parent = Path(context_path).parent / rel_file
+    if via_parent.exists():
+        return via_parent
+    direct = Path(rel_file)
+    if direct.exists():
+        return direct
+    return None
 
 
 class InterrogateParser(AbstractParser):
     """Parses raw output from ``interrogate -v`` into a ToolResult."""
 
     def parse(self, raw_result: RawResult) -> ToolResult:
-        files: dict[str, dict] = {}
-        total_coverage: float | None = None
+        cm = _CONTEXT_PATH_RE.search(raw_result.command)
+        context_path = cm.group(1) if cm else "."
+        interrogate_cfg = _load_interrogate_cfg(context_path)
+
+        # Interrogate reports paths relative to the package root it discovers,
+        # not relative to context_path. Parse the "Coverage for <dir>" header
+        # to compute the prefix needed to make paths project-relative.
+        prefix = ""
+        for line in (raw_result.stdout or "").splitlines():
+            hm = _COVERAGE_FOR_RE.search(line)
+            if hm:
+                coverage_root = hm.group(1).strip().rstrip("\\/")
+                try:
+                    rel = (
+                        Path(coverage_root)
+                        .resolve()
+                        .relative_to(Path(context_path).resolve())
+                    )
+                    prefix = rel.as_posix()
+                except ValueError:
+                    pass
+                break
+
+        summaries: dict[str, dict] = {}
         for line in (raw_result.stdout or "").splitlines():
             m = _ROW_RE.match(line)
             if not m:
                 continue
-            name = m.group(1).strip()
+            name = m.group(1).strip().replace("\\", "/")
             total = int(m.group(2))
             miss = int(m.group(3))
             cover = float(m.group(4))
-            if name == "TOTAL":
-                total_coverage = cover / 100.0
-            elif total > 0:
-                files[name.replace("\\", "/")] = {
+            if name != "TOTAL" and total > 0 and ".venv" not in name:
+                file_key = f"{prefix}/{name}" if prefix else name
+                summaries[file_key] = {
                     "total": total,
                     "missing": miss,
                     "coverage": cover / 100.0,
                 }
-        score = total_coverage if total_coverage is not None else 1.0
-        return ToolResult(raw=raw_result, metrics={"doc_coverage": score}, details=files)
-
-    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
-        score = tr.metrics.get("doc_coverage", 0)
-        uncovered = sorted(
-            [(f, d) for f, d in tr.details.items() if d.get("missing", 0) > 0],
-            key=lambda x: x[1]["coverage"],
-        )[:5]
-        if not uncovered:
+
+        if self.parser_config.get("skip_empty_init", True):
+            summaries = {
+                f: d
+                for f, d in summaries.items()
+                if not (
+                    Path(f).name == "__init__.py"
+                    and _is_file_empty(_resolve(context_path, f))
+                )
+            }
+
+        total_docs = sum(d["total"] for d in summaries.values())
+        missing_docs = sum(d["missing"] for d in summaries.values())
+        score = (total_docs - missing_docs) / total_docs if total_docs > 0 else 1.0
+
+        # Build per-issue list details (sorted worst-first) so _fingerprint_from_slice
+        # can produce a specific line+code fingerprint for is_fixed checks.
+        files: dict[str, list] = {}
+        for rel_file, summary in sorted(
+            summaries.items(), key=lambda x: x[1]["coverage"]
+        ):
+            if summary["missing"] == 0:
+                continue
+            resolved = _resolve(context_path, rel_file)
+            nodes = _missing_docstrings(resolved, interrogate_cfg) if resolved else []
+            issues = []
+            for lineno, kind, source_line in nodes:
+                if kind == "module":
+                    code, message = "D100", "missing module docstring"
+                    lineno = 1
+                elif kind == "class":
+                    nm = re.search(r"class\s+(\w+)", source_line)
+                    name = nm.group(1) if nm else source_line
+                    code, message = "D101", f"missing docstring in class `{name}`"
+                else:
+                    nm = re.search(r"def\s+(\w+)", source_line)
+                    name = nm.group(1) if nm else source_line
+                    code, message = "D103", f"missing docstring in function `{name}`"
+                issues.append(
+                    {
+                        "line": lineno if lineno > 0 else 1,
+                        "code": code,
+                        "message": message,
+                    }
+                )
+            if issues:
+                files[rel_file] = issues
+
+        return ToolResult(
+            raw=raw_result, metrics={"doc_coverage": score}, details=files
+        )
+
+    def format_llm_message(
+        self, tr: ToolResult, *, context_lines: int = 15, limit: int = 1
+    ) -> str:
+        result = extract_first_issue(tr.details)
+        if result is None:
+            score = tr.metrics.get("doc_coverage", 0)
             return f"**doc_coverage** score: {score:.3f}"
-        lines = [f"**doc coverage** {score:.1%} — files with most missing docstrings:"]
-        for path, data in uncovered:
-            miss = data["missing"]
-            pct = data["coverage"]
-            lines.append(f"- `{path}`: {pct:.0%} ({miss} undocumented)")
-        return "\n".join(lines)
+
+        m = _CONTEXT_PATH_RE.search(tr.raw.command)
+        context_path = m.group(1) if m else "."
+
+        rel_file, issue = result
+        line = issue.get("line", 1)
+        code = issue.get("code", "D100")
+        message = issue.get("message", "missing docstring")
+
+        resolved = _resolve(context_path, rel_file)
+        file_str = str(resolved) if resolved else rel_file
+
+        return _format_missing_docstring(file_str, line, code, message)

py_cq/parsers/linecountparser.py

@@ -12,13 +12,21 @@ class LineCountParser(AbstractParser):
     """
 
     def parse(self, raw_result: RawResult) -> ToolResult:
+        """
+        Parse the raw result to count non-empty lines and calculate the violation score.
+        """
         lines = [ln for ln in (raw_result.stdout or "").splitlines() if ln.strip()]
         count = len(lines)
         scale = self.parser_config.get("scale_factor", 15)
         score = score_logistic_variant(count, scale_factor=scale)
-        return ToolResult(raw=raw_result, metrics={"violations": score}, details={"lines": lines})
+        return ToolResult(
+            raw=raw_result, metrics={"violations": score}, details={"lines": lines}
+        )
 
-    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+    def format_llm_message(
+        self, tr: ToolResult, *, context_lines: int = 15, limit: int = 1
+    ) -> str:
+        """Formats the ToolResult lines into a string for the LLM message."""
         lines = tr.details.get("lines", [])
         if not lines:
             return "No violations found"

py_cq/parsers/maintainabilityparser.py

@@ -4,10 +4,8 @@ The `MaintainabilityParser` implements the `AbstractParser` interface to
 convert raw JSON output from a maintainability tool into a
 `ToolResult` structure that other components of the framework can consume."""
 
-import json
-
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
-from py_cq.parsers.common import score_logistic_variant
+from py_cq.parsers.common import parse_json_dict, score_logistic_variant
 
 
 class MaintainabilityParser(AbstractParser):
@@ -41,7 +39,10 @@ class MaintainabilityParser(AbstractParser):
                 * ``details`` - a mapping from each file name (converted to use forward slashes) to a dictionary with keys ``mi``, ``rank``, and optionally ``error``.
                 * ``details['return_code']`` - the tool's exit code."""
         tr = ToolResult(raw=raw_result)
-        data = json.loads(raw_result.stdout)
+        data = parse_json_dict(raw_result.stdout)
+        if data is None:
+            tr.metrics["maintainability"] = 0.0
+            return tr
         num_items = 0
         score = 0
         for file, values in data.items():
@@ -61,3 +62,32 @@ class MaintainabilityParser(AbstractParser):
                 }
         tr.metrics["maintainability"] = score / num_items if num_items > 0 else 0.0
         return tr
+
+    def format_llm_message(
+        self, tr: ToolResult, *, context_lines: int = 15, limit: int = 1
+    ) -> str:
+        """Format the LLM message with details about the worst maintainability scores."""
+        worst_file = worst_rank = None
+        worst_score = 1.0
+        for file, data in tr.details.items():
+            if not isinstance(data, dict):
+                continue
+            error = data.get("error")
+            score = data.get("mi", 1.0)
+            if score < worst_score:
+                worst_score = score
+                worst_file = file
+                worst_rank = data.get("rank", "F")
+                if error:
+                    worst_rank = f"F (error: {error})"
+        if worst_file is None:
+            if tr.metrics:
+                metric_name, value = next(iter(tr.metrics.items()))
+                return f"**{metric_name}** score: {value:.3f}"
+            return "No maintainability details available"
+        return (
+            f"`{worst_file}` - maintainability rank **{worst_rank}**\n\n"
+            "The maintainability index is low. Common causes: long functions, high complexity, "
+            "deeply nested logic, or lack of comments. Refactor by extracting helpers and "
+            "simplifying control flow."
+        )

py_cq/parsers/pytestparser.py

@@ -8,11 +8,24 @@ process return code so downstream components can uniformly consume results
 from multiple test tools.  It is part of the test-collection framework and
 enables consistent handling of pytest output across the system."""
 
+import functools
 import re as _re
+from pathlib import Path as _Path
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
 
 
+@functools.lru_cache(maxsize=64)
+def _section_pattern(test_name: str) -> _re.Pattern:
+    return _re.compile(rf"_{{4,}}\s+{_re.escape(test_name)}\s+_{{4,}}")
+
+
+def _target_dir(command: str) -> str:
+    """Extract the --directory value from a uv run command, or ''."""
+    m = _re.search(r'--directory\s+"?([^"\s]+)"?', command)
+    return m.group(1) if m else ""
+
+
 def _last_call_line_for_test(stdout: str, test_name: str) -> str:
     """Return the last source line before E-lines in a test's failure section.
 
@@ -20,7 +33,7 @@ def _last_call_line_for_test(stdout: str, test_name: str) -> str:
     current-executing-line marker.
     """
     lines = stdout.splitlines()
-    pattern = _re.compile(rf"_{{4,}}\s+{_re.escape(test_name)}\s+_{{4,}}")
+    pattern = _section_pattern(test_name)
     in_section = False
     last_src = ""
     for line in lines:
@@ -68,7 +81,7 @@ def _extract_collection_error(stdout: str) -> dict | None:
 def _extract_failure(stdout: str, test_name: str, max_lines: int) -> str:
     """Extract the failure section for test_name from pytest stdout."""
     lines = stdout.splitlines()
-    pattern = _re.compile(rf"_{{4,}}\s+{_re.escape(test_name)}\s+_{{4,}}")
+    pattern = _section_pattern(test_name)
     start = None
     for i, line in enumerate(lines):
         if pattern.search(line):
@@ -76,14 +89,37 @@ def _extract_failure(stdout: str, test_name: str, max_lines: int) -> str:
             break
     if start is None:
         return ""
-    collected = []
+    # Collect the full block - skip sub-section dividers ("_ _ _") but stop at
+    # the next test header ("____") or summary line ("====").
+    section = []
     for line in lines[start:]:
-        if line.strip().startswith("_") or line.strip().startswith("="):
-            break
-        collected.append(line)
-        if len(collected) >= max_lines:
+        stripped = line.strip()
+        if _re.match(r"_{4,}", stripped) or stripped.startswith("="):
             break
-    text = "\n".join(collected).strip()
+        section.append(line)
+    # Prefer E-lines (the actual assertion / exception messages).
+    e_lines = [ln for ln in section if ln.startswith("E ") or ln.strip() == "E"]
+    if e_lines:
+        arrow_lines = [
+            ln.lstrip("> \t")
+            for ln in section
+            if ln.startswith(">") and ln.lstrip("> \t")
+        ]
+        cleaned = [_re.sub(r"^E\s*", "", ln) for ln in e_lines]
+        # Drop "At index N diff:" lines - always redundant with the first E-line.
+        cleaned = [ln for ln in cleaned if not _re.match(r"At index \d+ diff:", ln)]
+        parts = ([f"> {arrow_lines[-1]}"] if arrow_lines else []) + cleaned
+        text = "\n".join(parts[:max_lines]).strip()
+    else:
+        # Fall back: show the traceback up to max_lines, stopping before E-lines.
+        sub = []
+        for line in section:
+            if line.startswith("E ") or line.strip() == "E":
+                break
+            sub.append(line)
+            if len(sub) >= max_lines:
+                break
+        text = "\n".join(sub).strip()
     return f"\n```\n{text}\n```" if text else ""
 
 
@@ -132,7 +168,10 @@ class PytestParser(AbstractParser):
             passed_tests = 0
             for line in lines:
                 # tests/test_common.py::test_name[param] PASSED    [ 8%]
-                tests_match = _re.search(r"(.*\.py)::([\w\[\].,+\- ]+) (PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)", line)
+                tests_match = _re.search(
+                    r"(.*\.py)::([\w\[\].,+\- ]+) (PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)",
+                    line,
+                )
                 if tests_match:
                     test_file = tests_match.group(1)
                     test_name = tests_match.group(2).strip()
@@ -144,7 +183,9 @@ class PytestParser(AbstractParser):
             if num_tests == 0:
                 # No individual test lines found (e.g. non-verbose output);
                 # fall back to parsing the pytest summary line.
-                summary = _re.search(r"(\d+) passed(?:.*?(\d+) failed)?", raw_result.stdout)
+                summary = _re.search(
+                    r"(\d+) passed(?:.*?(\d+) failed)?", raw_result.stdout
+                )
                 if summary:
                     passed_tests = int(summary.group(1))
                     failed_tests = int(summary.group(2)) if summary.group(2) else 0
@@ -153,29 +194,40 @@ class PytestParser(AbstractParser):
             tr.details = tests_found
         return tr
 
-    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+    def format_llm_message(
+        self, tr: ToolResult, *, context_lines: int = 15, limit: int = 1
+    ) -> str:
         """Return the first failing test with function body, failure output, and callee signature."""
         from py_cq.parsers.common import (
             extract_callee_name,
             find_function_source,
             format_callee_context,
         )
+
         for file, tests in tr.details.items():
             if not isinstance(tests, dict):
                 continue
             for test_name, status in tests.items():
                 if status != "FAILED":
                     continue
-                header = f"`{file}::{test_name}` — test **FAILED**"
+                header = f"`{file}::{test_name}` - test **FAILED**"
                 bare_name = test_name.split("[")[0]
-                body = find_function_source(file, bare_name, max_lines=context_lines)
-                failure = _extract_failure(tr.raw.stdout, test_name, max_lines=context_lines)
+                tdir = _target_dir(tr.raw.command)
+                resolved = (
+                    (_Path(tdir) / file).as_posix()
+                    if tdir and not _Path(file).is_absolute()
+                    else file
+                )
+                body = find_function_source(
+                    resolved, bare_name, max_lines=context_lines
+                )
+                failure = _extract_failure(tr.raw.stdout, test_name, max_lines=50)
                 callee = ""
                 call_line = _last_call_line_for_test(tr.raw.stdout, test_name)
                 if call_line:
                     func_name = extract_callee_name(call_line)
                     if func_name and func_name != bare_name:
-                        callee = format_callee_context(func_name, file)
+                        callee = format_callee_context(func_name, resolved)
                 parts = [header]
                 if body:
                     parts.append(body)
@@ -186,19 +238,24 @@ class PytestParser(AbstractParser):
                 return "\n".join(parts)
         if "no tests ran" in tr.raw.stdout:
             return (
-                "**No tests found.** This project has no pytest test suite.\n\n"
-                "Add a `tests/` directory with at least one test file (e.g. `tests/test_basic.py`) "
-                "and write a first test covering a core function."
+                "**No tests found.** pytest ran but collected nothing.\n\n"
+                "Create `tests/test_basic.py` and write a first test covering a core function."
             )
         from py_cq.parsers.common import (
             extract_callee_name,
             format_callee_context,
             format_source_context,
         )
+
         combined = tr.raw.stdout + tr.raw.stderr
         err = _extract_collection_error(combined)
         if err:
-            file, line, typ, help_msg = err["file"], err["line"], err["type"], err["help"]
+            file, line, typ, help_msg = (
+                err["file"],
+                err["line"],
+                err["type"],
+                err["help"],
+            )
             code_block = format_source_context(file, line, count=context_lines) or ""
             callee = ""
             # try to find callee from the offending source line via format_source_context result
@@ -211,7 +268,7 @@ class PytestParser(AbstractParser):
                 func_name = extract_callee_name(src_line)
                 if func_name:
                     callee = format_callee_context(func_name, file)
-            return f"`{file}:{line}` — **{typ}**: {help_msg}{code_block}{callee}"
+            return f"`{file}:{line}` - **{typ}**: {help_msg}{code_block}{callee}"
         output = combined.strip()
         if output:
             tail = "\n".join(output.splitlines()[-30:])

py_cq/parsers/regexcountparser.py

@@ -1,5 +1,6 @@
 """Parser that counts stdout lines matching a regex pattern."""
 
+import functools
 import re
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
@@ -14,11 +15,17 @@ class RegexCountParser(AbstractParser):
         scale_factor (int, default 15): passed to score_logistic_variant.
     """
 
+    @functools.cached_property
+    def _pattern(self) -> re.Pattern:
+        return re.compile(self.parser_config["pattern"])
+
     def parse(self, raw_result: RawResult) -> ToolResult:
-        pattern = re.compile(self.parser_config["pattern"])
+        """
+        Parses the raw result using a regex pattern and computes a score.
+        """
         scale = self.parser_config.get("scale_factor", 15)
         lines = (raw_result.stdout or "").splitlines()
-        matches = [ln for ln in lines if pattern.search(ln)]
+        matches = [ln for ln in lines if self._pattern.search(ln)]
         count = len(matches)
         score = score_logistic_variant(count, scale_factor=scale)
         return ToolResult(
@@ -27,7 +34,10 @@ class RegexCountParser(AbstractParser):
             details={"count": count, "matches": matches},
         )
 
-    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+    def format_llm_message(
+        self, tr: ToolResult, *, context_lines: int = 15, limit: int = 1
+    ) -> str:
+        """Formats the LLM message with match details."""
         matches = tr.details.get("matches", [])
         if not matches:
             return "No violations found"