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

py_cq/parsers/coverageparser.py

@@ -1,88 +1,202 @@
-"""Parses raw coverage tool output into a standardized `ToolResult` for consistent analysis across different coverage utilities.
-The module defines `CoverageParser`, a concrete implementation of `AbstractParser`, which extracts overall and per-file coverage metrics from a `RawResult` object and normalises the data format for downstream processing."""
+"""Parses raw coverage tool output into structured ToolResult instances with per-function granularity."""
 
+import ast
 import logging
+from pathlib import Path
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+from py_cq.parsers.common import find_function_source, resolve_path
 
 log = logging.getLogger("cq")
 
 
+def _parse_line_ranges(s: str) -> set[int]:
+    """Parse a comma-separated string of line ranges and individual lines.
+
+    Example: "1, 3-5, 10" -> {1, 3, 4, 5, 10}
+    """
+    result: set[int] = set()
+    for part in s.split(","):
+        part = part.strip()
+        if "-" in part:
+            lo, hi = part.split("-", 1)
+            try:
+                result.update(range(int(lo), int(hi) + 1))
+            except ValueError:
+                pass
+        elif part.isdigit():
+            result.add(int(part))
+    return result
+
+
+def _get_signature(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
+    """Return the signature of the function definition as a string."""
+    prefix = "async def" if isinstance(node, ast.AsyncFunctionDef) else "def"
+    args = ast.unparse(node.args)
+    returns = f" -> {ast.unparse(node.returns)}" if node.returns else ""
+    return f"{prefix} {node.name}({args}){returns}"
+
+
+def _extract_functions(file: str, missing_lines_str: str) -> list[tuple[str, int, str]]:
+    """Return (name, lineno, signature) for functions whose bodies overlap with the missing line ranges."""
+    try:
+        source = Path(file).read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(source)
+    except (OSError, SyntaxError, ValueError):
+        return []
+    missing = _parse_line_ranges(missing_lines_str)
+    seen: set[str] = set()
+    result: list[tuple[str, int, str]] = []
+    for node in sorted(ast.walk(tree), key=lambda n: getattr(n, "lineno", 0)):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            end = getattr(node, "end_lineno", node.lineno)
+            if missing & set(range(node.lineno, end + 1)) and node.name not in seen:
+                seen.add(node.name)
+                result.append((node.name, node.lineno, _get_signature(node)))
+    return result
+
+
+def _find_test_file(source_file: str) -> str | None:
+    """Return the test file path for source_file if a tests/ directory exists nearby."""
+    candidate_name = f"test_{Path(source_file).stem}.py"
+    try:
+        for ancestor in Path(source_file).parents:
+            try:
+                tests_dir = ancestor / "tests"
+                if tests_dir.is_dir():
+                    return str(tests_dir / candidate_name).replace("\\", "/")
+            except (OSError, ValueError):
+                pass
+    except (OSError, ValueError):
+        pass
+    return None
+
+
 class CoverageParser(AbstractParser):
-    """Parses raw coverage output into structured ToolResult instances.
-    Extends AbstractParser, extracting overall coverage percentages, per-file coverage values, normalising file paths, and preserving the tool's return code."""
+    """Parser for coverage results."""
 
     def parse(self, raw_result: RawResult) -> ToolResult:
-        """Parse raw coverage output into a :class:`ToolResult`.
-
-        Given a :class:`RawResult` containing the stdout of a coverage tool, the
-        method extracts every line that ends with a percent sign.  Each such line
-        is expected to follow the format::
-
-            <file> <total_lines> <covered_lines> <coverage>%
-
-        The coverage percentage is converted to a fraction (e.g. 90\u202f% → 0.9) and
-        stored in ``metrics['coverage']`` for the overall ``TOTAL`` line, while
-        the per-file values are placed in ``details`` with the file path
-        normalised to use forward slashes.  The tool's return code is added to
-        ``details`` under the key ``'return_code'``.
-
-        Args:
-            raw_result (RawResult): The raw output from a coverage tool.
-
-        Returns:
-            ToolResult: A structured result containing the overall coverage
-            metric, per-file coverage percentages, and the tool's return code.
-
-        Example:
-            >>> parser = CoverageParser()
-            >>> raw = RawResult(
-            ...     stdout='src/main.py 100 90 90%\\\\nTOTAL 200 180 90%',
-            ...     return_code=0)
-            >>> result = parser.parse(raw)
-            >>> result.metrics['coverage']
-            0.9
-            >>> result.details['src/main.py']
-            0.9"""
-        tr = ToolResult(raw=raw_result)
+        """Parse the coverage result."""
+        tr = ToolResult(raw=raw_result, project_path=raw_result.project_path)
         lines = raw_result.stdout.splitlines()
-        coverage_lines = [line for line in lines if line.endswith("%")]
-        details = {}
-        for line in coverage_lines:
+        base_dir = raw_result.project_path
+
+        file_data: dict[str, dict] = {}
+        for line in lines:
+            if "[" in line:
+                continue
             parts = line.split()
-            if len(parts) >= 2:
-                file_name = parts[0]
+            if len(parts) < 4 or not parts[3].endswith("%"):
+                continue
+            file_name = parts[0]
+            try:
+                coverage_pct = float(parts[3].rstrip("%")) / 100.0
+            except ValueError:
+                log.warning("Error parsing coverage percentage from line: %s", line)
+                continue
+            if file_name == "TOTAL":
+                tr.metrics["coverage"] = coverage_pct
+            else:
                 try:
-                    coverage_percentage = float(parts[-1].rstrip('%')) / 100.0
-                except ValueError:
-                    log.warning("Error parsing coverage percentage from line: %s", line)
+                    missing = int(parts[2])
+                except (ValueError, IndexError):
+                    missing = None
+                missing_lines = " ".join(parts[4:]) if len(parts) > 4 else None
+                file_data[file_name.replace("\\", "/")] = {
+                    "coverage": coverage_pct,
+                    "missing": missing,
+                    "missing_lines": missing_lines,
+                }
+
+        # Build list-based details sorted worst-coverage-first so _single_issue_slices
+        # picks the most urgent file and function first.
+        details: dict[str, list] = {}
+        for file_name, data in sorted(
+            file_data.items(), key=lambda x: x[1].get("coverage", 1.0)
+        ):
+            if data.get("missing") == 0:
+                continue
+            missing_lines_str = data.get("missing_lines")
+            coverage_pct = data["coverage"]
+            missing_count = data["missing"]
+            resolved = resolve_path(base_dir, file_name)
+            if missing_lines_str:
+                funcs = _extract_functions(resolved, missing_lines_str)
+                if funcs:
+                    details[file_name] = [
+                        {
+                            "code": name,
+                            "line": lineno,
+                            "signature": sig,
+                            "file_coverage": coverage_pct,
+                            "missing": missing_count,
+                        }
+                        for name, lineno, sig in funcs
+                    ]
                     continue
-                if file_name == "TOTAL":
-                    tr.metrics["coverage"] = coverage_percentage
-                else:
-                    try:
-                        missing = int(parts[2]) if len(parts) >= 4 else None
-                    except (ValueError, IndexError):
-                        missing = None
-                    details[file_name.replace("\\", "/")] = {
-                        "coverage": coverage_percentage,
-                        "missing": missing,
-                    }
+            # Fallback when --show-missing wasn't used or AST parsing failed
+            details[file_name] = [
+                {
+                    "code": None,
+                    "line": None,
+                    "missing": missing_count,
+                    "missing_lines": missing_lines_str,
+                    "file_coverage": coverage_pct,
+                }
+            ]
+
         tr.details = details
         return tr
 
-    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
-        """Return the files with lowest coverage as a defect description."""
-        score = tr.metrics.get("coverage", 0)
-        uncovered = sorted(
-            [(f, d) for f, d in tr.details.items() if isinstance(d, dict) and d.get("missing")],
-            key=lambda x: x[1]["coverage"],
-        )[:5]
-        if not uncovered:
-            return f"**coverage** score: {score:.3f}"
-        lines = [f"**coverage** score: {score:.3f} — files with lowest coverage:"]
-        for path, data in uncovered:
-            pct = data["coverage"]
-            miss = data["missing"]
-            lines.append(f"- `{path}`: {pct:.0%} ({miss} uncovered statements)")
-        return "\n".join(lines)
+    def format_llm_message(
+        self, tr: ToolResult, *, context_lines: int = 15, limit: int = 1
+    ) -> str:
+        for file, issues in tr.details.items():
+            if not isinstance(issues, list) or not issues:
+                continue
+            issue = issues[0]
+            if not isinstance(issue, dict):
+                continue
+            code = issue.get("code")
+            line = issue.get("line")
+            missing = issue.get("missing")
+            file_coverage = issue.get("file_coverage", 0.0)
+            missing_lines = issue.get("missing_lines")
+            try:
+                resolved_file = resolve_path(tr.project_path, file)
+            except (OSError, ValueError):
+                resolved_file = file
+
+            parts: list[str] = []
+            if code and line:
+                parts.append(f"{file}:{line} - {code} is missing tests")
+                fn_src = find_function_source(resolved_file, code)
+                if fn_src:
+                    parts.append(fn_src)
+            else:
+                pct = (
+                    f"{file_coverage:.0%} "
+                    if isinstance(file_coverage, float) and file_coverage
+                    else ""
+                )
+                miss_info = f"{missing} uncovered lines" if missing else "uncovered"
+                parts.append(f"{file} - {pct}coverage ({miss_info})")
+                if missing_lines:
+                    parts.append(f"  missing lines: {missing_lines}")
+
+            test_file = _find_test_file(file)
+            if test_file:
+                try:
+                    resolved_test = resolve_path(tr.project_path, test_file)
+                    last_line = len(
+                        Path(resolved_test).read_text(encoding="utf-8").splitlines()
+                    )
+                except (OSError, ValueError):
+                    last_line = None
+                location = (
+                    f"{test_file} after line {last_line}" if last_line else test_file
+                )
+                parts.append(f"\nAdd tests to: {location}")
+
+            return "\n".join(parts)
+        return ""

py_cq/parsers/exitcodeparser.py

@@ -7,10 +7,19 @@ class ExitCodeParser(AbstractParser):
     """Score 1.0 if the tool exited with code 0, else 0.0."""
 
     def parse(self, raw_result: RawResult) -> ToolResult:
+        """Parse the tool result and return a score based on the exit code."""
         score = 1.0 if raw_result.return_code == 0 else 0.0
         return ToolResult(raw=raw_result, metrics={"exit_code": score})
 
-    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:
+        """Format the tool result as a string message for the LLM."""
+
         output = tr.raw.stdout.strip() or tr.raw.stderr.strip()
         lines = output.splitlines()[:context_lines]
-        return "\n".join(lines) if lines else "Tool exited with non-zero status (no output)"
+        return (
+            "\n".join(lines)
+            if lines
+            else "Tool exited with non-zero status (no output)"
+        )

py_cq/parsers/halsteadparser.py

@@ -5,10 +5,8 @@ converts the JSON output from Halstead metric tools into a
 ``ToolResult``.  It extracts bug estimates and program volume, applies
 maximum thresholds, and aggregates file- and function-level metrics."""
 
-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 _relative_path, parse_json_dict, score_logistic_variant
 
 
 class HalsteadParser(AbstractParser):
@@ -27,7 +25,7 @@ class HalsteadParser(AbstractParser):
     def parse(self, raw_result: RawResult) -> ToolResult:
         """Parses Halstead tool JSON output and returns a ToolResult.
 
-        The method reads ``raw_result.stdout``—a JSON string containing
+        The method reads ``raw_result.stdout``-a JSON string containing
         per-file and per-function Halstead metrics. For each file it
         populates a ``ToolResult`` detail entry with bug-free and
         smallness scores. If a file contains an ``error`` key, the
@@ -59,15 +57,23 @@ class HalsteadParser(AbstractParser):
         #  {"total": {"h1": 6, "h2": 18, "N1": 13, "N2": 22, "vocabulary": 24, "length": 35, "calculated_length": 90.56842503028855, "volume": 160.4736875252405, "difficulty": 3.6666666666666665, "effort": 588.4035209258818, "time": 32.68908449588233, "bugs": 0.05349122917508017},
         #   "functions": {"calc_dist": {"h1": 3, "h2": 9, "N1": 5, "N2": 10, "vocabulary": 12, "length": 15, "calculated_length": 33.28421251514428, "volume": 53.77443751081735, "difficulty": 1.6666666666666667, "effort": 89.62406251802892, "time": 4.9791145843349405, "bugs": 0.017924812503605784}, "find_nearest_city": {"h1": 1, "h2": 2, "N1": 1, "N2": 2, "vocabulary": 3, "length": 3, "calculated_length": 2.0, "volume": 4.754887502163469, "difficulty": 0.5, "effort": 2.3774437510817346, "time": 0.1320802083934297, "bugs": 0.0015849625007211565}, "generate_tour": {"h1": 2, "h2": 5, "N1": 6, "N2": 8, "vocabulary": 7, "length": 14, "calculated_length": 13.60964047443681, "volume": 39.302968908806456, "difficulty": 1.6, "effort": 62.884750254090335, "time": 3.493597236338352, "bugs": 0.01310098963626882}, "main": {"h1": 0, "h2": 0, "N1": 0, "N2": 0, "vocabulary": 0, "length": 0, "calculated_length": 0, "volume": 0, "difficulty": 0, "effort": 0, "time": 0.0, "bugs": 0.0}}}
         tr = ToolResult(raw=raw_result)
+        data = parse_json_dict(raw_result.stdout)
+        if data is None:
+            tr.metrics = {
+                "file_bug_free": 1.0,
+                "file_smallness": 1.0,
+                "functions_bug_free": 1.0,
+                "functions_smallness": 1.0,
+            }
+            return tr
         MAX_FILE_BUGS = 1
-        MAX_FILE_VOLUME = 2000
+        MAX_FILE_VOLUME = 3000
         MAX_FUNCTION_BUGS = 0.2
         MAX_FUNCTION_VOLUME = 600
         min_file_nb = 1.0
         min_file_sm = 1.0
         min_function_nb = 1.0
         min_function_sm = 1.0
-        data = json.loads(raw_result.stdout)
         for file, values in data.items():
             file_name = file.replace("\\", "/")
             if file_name not in tr.details:
@@ -104,6 +110,7 @@ class HalsteadParser(AbstractParser):
                         "smallness": sm,
                         "bugs": function_values.get("bugs", 0),
                         "volume": function_values.get("volume", 0),
+                        "difficulty": function_values.get("difficulty", 0),
                     }
         tr.metrics = {
             "file_bug_free": min_file_nb,
@@ -113,7 +120,9 @@ class HalsteadParser(AbstractParser):
         }
         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 worst Halstead offender as an actionable defect description."""
         if not tr.metrics:
             return "No Halstead details available"
@@ -127,6 +136,7 @@ class HalsteadParser(AbstractParser):
         worst_score = 1.0
         worst_bugs = None
         worst_volume = None
+        worst_difficulty = None
 
         for file_name, file_data in tr.details.items():
             if is_function_metric:
@@ -138,6 +148,7 @@ class HalsteadParser(AbstractParser):
                         worst_function = func_name
                         worst_bugs = func_data.get("bugs")
                         worst_volume = func_data.get("volume")
+                        worst_difficulty = func_data.get("difficulty")
             else:
                 s = file_data.get("bug_free" if is_bug_metric else "smallness", 1.0)
                 if s < worst_score:
@@ -149,15 +160,32 @@ class HalsteadParser(AbstractParser):
         if worst_file is None:
             return f"**{metric_name}** score: {score:.3f}"
 
-        location = f"`{worst_file}` — function `{worst_function}`" if worst_function else f"`{worst_file}`"
+        path = _relative_path(worst_file)
+        location = f"{path} - function `{worst_function}`" if worst_function else path
         if is_bug_metric:
-            detail = f" (Halstead bug estimate: {worst_bugs:.3f})" if worst_bugs is not None else ""
-            return (
-                f"{location} has high estimated bug density{detail}\n\n"
-                f"Reduce complexity by extracting helper functions or simplifying logic."
-            )
+            parts = []
+            if worst_bugs is not None:
+                parts.append(f"bugs: {worst_bugs:.3f}")
+            if worst_volume is not None:
+                parts.append(f"volume: {worst_volume:.0f}")
+            if worst_difficulty is not None:
+                parts.append(f"difficulty: {worst_difficulty:.1f}")
+            detail = f" ({', '.join(parts)})" if parts else ""
+            if (
+                worst_difficulty is not None
+                and worst_volume is not None
+                and worst_difficulty > worst_volume / 50
+            ):
+                advice = "Simplify branching logic, reduce nesting, or consolidate repeated operator patterns."
+            else:
+                advice = (
+                    "Extract helper functions to reduce the function's size and scope."
+                )
+            return f"{location} has high estimated bug density{detail}\n\n{advice}"
         else:
-            detail = f" (volume: {worst_volume:.0f})" if worst_volume is not None else ""
+            detail = (
+                f" (volume: {worst_volume:.0f})" if worst_volume is not None else ""
+            )
             return (
                 f"{location} is too large{detail}\n\n"
                 f"Split into smaller functions or modules."