python-code-quality 0.1.14__tar.gz → 0.1.16__tar.gz

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-code-quality
-Version: 0.1.14
+Version: 0.1.16
 Summary: Python Code Quality Analysis Tool - feed the results from 11 CQ tools straight into an LLM. Minimal tokens.
 Author: Chris Kilner
 Author-email: Chris Kilner <chris@rhiza.fr>
@@ -37,6 +37,10 @@ Description-Content-Type: text/markdown
 
 Run 11+ code quality tools, aggregate results into one score, and surface the single most critical defect as a focused markdown prompt — ready to pipe to any LLM.
 
+This can dramatically reduce the amount of noise for LLMs (and humans) and remove the need for them to know about these tools.
+
+Note: It never edits your files. This is a job for you or an LLM. You may wish to run `ruff check --fix` and `ruff format` first.
+
 ```bash
 cq check . -o llm     # top defect as markdown, pipe to an LLM
 cq check .            # table overview of all scores
@@ -175,7 +179,7 @@ Then invoke it with `/cq-fix` in Claude Code. The `$(...)` embeds the live `cq`
 ```bash
 > cq check . -o score
 ```
-```python
+```
 0.9662730667181059 # this is designed to approach but not reach 1.0
 ```
 

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/README.md

@@ -8,6 +8,10 @@
 
 Run 11+ code quality tools, aggregate results into one score, and surface the single most critical defect as a focused markdown prompt — ready to pipe to any LLM.
 
+This can dramatically reduce the amount of noise for LLMs (and humans) and remove the need for them to know about these tools.
+
+Note: It never edits your files. This is a job for you or an LLM. You may wish to run `ruff check --fix` and `ruff format` first.
+
 ```bash
 cq check . -o llm     # top defect as markdown, pipe to an LLM
 cq check .            # table overview of all scores
@@ -146,7 +150,7 @@ Then invoke it with `/cq-fix` in Claude Code. The `$(...)` embeds the live `cq`
 ```bash
 > cq check . -o score
 ```
-```python
+```
 0.9662730667181059 # this is designed to approach but not reach 1.0
 ```
 

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-code-quality"
-version = "0.1.14"
+version = "0.1.16"
 description = "Python Code Quality Analysis Tool - feed the results from 11 CQ tools straight into an LLM. Minimal tokens."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -47,5 +47,14 @@ cq = "py_cq.main:main"
 testpaths = ["tests"]
 norecursedirs = [".venv", "dist"]
 
+[[tool.ty.overrides]]
+include = ["demo/**"]
+rules = {unresolved-import = "ignore"}
+
 [tool.cq]
 exclude = ["demo"]
+
+[dependency-groups]
+dev = [
+    "hypothesis>=6.151.10",
+]

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/cli.py

@@ -10,13 +10,14 @@ analysis.
 Helper functions such as `format_as_table` convert the aggregated tool
 results into a Rich Table for convenient console display.
 """
-
 import copy
+import io
 import json
 import logging
 import tomllib
 from enum import Enum
 from importlib import import_module
+from importlib.metadata import requires, version
 from pathlib import Path
 
 import typer
@@ -28,8 +29,9 @@ from py_cq.config import load_user_config
 from py_cq.execution_engine import _cache as tool_cache
 from py_cq.execution_engine import run_tools
 from py_cq.language_detector import detect_language
-from py_cq.localtypes import CombinedToolResults, ToolConfig
+from py_cq.localtypes import ToolConfig
 from py_cq.metric_aggregator import aggregate_metrics
+from py_cq.table_formatter import format_as_table
 from py_cq.tool_registry import tool_registry
 
 logging.basicConfig(
@@ -100,8 +102,36 @@ class OutputMode(str, Enum):
     RAW = "raw"
 
 
+def _version_callback(value: bool) -> None:
+    if not value:
+        return
+    import re
+    import sys
+    if isinstance(sys.stdout,  io.TextIOWrapper):  # pragma: no branch
+        sys.stdout.reconfigure(encoding="utf-8")
+    pkg = "python-code-quality"
+    pkg_version = version(pkg)
+    dep_versions: list[tuple[str, str]] = []
+    for req in (requires(pkg) or []):
+        if "; extra ==" in req:
+            continue
+        dep_name = re.split(r"[>=<!;\s\[]", req)[0]
+        try:
+            dep_versions.append((dep_name, version(dep_name)))
+        except Exception:
+            pass
+    typer.echo(f"{pkg} v{pkg_version}")
+    for dep_name, dep_ver in sorted(dep_versions):
+        typer.echo(f"\u251c\u2500\u2500 {dep_name} v{dep_ver}")
+    raise typer.Exit()
+
+
 @app.callback()
-def callback():
+def callback(
+    _: bool = typer.Option(
+        False, "--version", "-V", callback=_version_callback, is_eager=True, help="Show version and dependencies"
+    ),
+) -> None:
     """Feed the results from 11+ code quality tools to an LLM. Try: cq check . -o llm"""
 console = Console()
 
@@ -156,7 +186,7 @@ def check(
     if path_obj.is_file():
         if path_obj.suffix != ".py":
             raise typer.BadParameter(f"File must be a Python file (.py): {path}")
-    elif path_obj.is_dir():
+    elif path_obj.is_dir():  # pragma: no branch
         if not (path_obj / "pyproject.toml").exists():
             raise typer.BadParameter(f"Directory must contain pyproject.toml: {path}")
     log.setLevel(log_level)
@@ -187,7 +217,7 @@ def check(
     elif output == OutputMode.LLM:
         # log.setLevel("CRITICAL")
         from py_cq.llm_formatter import format_for_llm
-        console.print(format_for_llm(effective_registry, combined_metrics, context_lines=context_lines))
+        print(format_for_llm(effective_registry, combined_metrics, context_lines=context_lines))
     else:
         console.print(f"[bold green]{path_obj.resolve()}[/]")
         console.print(format_as_table(combined_metrics, effective_registry))
@@ -255,41 +285,3 @@ def config(
     console.print(table)
 
 
-def format_as_table(data: CombinedToolResults, registry: dict[str, ToolConfig]):
-    """Format combined tool results into a Rich Table.
-
-    Args:
-        data (CombinedToolResults): Aggregated tool results, including the path,
-            individual tool results, and the overall score.
-
-    Returns:
-        rich.table.Table: A Rich table with columns ``Tool``, ``Metric``, ``Score`` and
-        ``Status``. Each metric row displays a status icon based on thresholds from
-        the tool's configuration. The table is titled with the data path and ends
-        with a row showing the overall score.
-
-    Example:
-        >>> table = format_as_table(combined_results)
-        >>> console.print(table)
-    """
-    table = Table(width=80)
-    table.add_column("Tool", justify="left", no_wrap=True)
-    table.add_column("Time", justify="right", style="dim")
-    table.add_column("Metric", justify="right", style="cyan", no_wrap=True)
-    table.add_column("Score", style="magenta")
-    table.add_column("Status")
-    for tr in data.tool_results:
-        tool_name = tr.raw.tool_name
-        config = next((t for t in registry.values() if t.name == tool_name))
-        for i, (name, value) in enumerate(tr.metrics.items()):
-            status = ""
-            if value < config.error_threshold:
-                status = "[bold red]Error[/]"
-            elif value < config.warning_threshold:
-                status = "[yellow]Warning[/]"
-            else:
-                status = "[green]OK[/]"
-            time_str = f"{tr.duration_s:.2f}s" if i == 0 else ""
-            table.add_row(tool_name, time_str, name, f"{value:0.3f}", status)
-    table.add_row("", "", "[bold]Score[/]", f"[bold]{data.score:0.3f}[/]", "")
-    return table

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/main.py

@@ -8,5 +8,5 @@ def main():
     app()
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     main()

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/banditparser.py

@@ -22,6 +22,8 @@ class BanditParser(AbstractParser):
             data = json.loads(raw_result.stdout)
         except (json.JSONDecodeError, ValueError):
             return ToolResult(raw=raw_result, metrics={"security": 1.0})
+        if not isinstance(data, dict):
+            return ToolResult(raw=raw_result, metrics={"security": 1.0})
 
         files: dict[str, list] = {}
         weighted = 0
@@ -46,7 +48,11 @@ class BanditParser(AbstractParser):
         if not tr.details:
             return "bandit reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
+        if not isinstance(issues, list) or not issues:
+            return "bandit reported issues (no details available)"
         issue = issues[0]
+        if not isinstance(issue, dict):
+            return "bandit reported issues (no details available)"
         line = issue.get("line", "?")
         code = issue.get("code", "")
         severity = issue.get("severity", "")

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/common.py

@@ -12,39 +12,134 @@ performance metrics or error scores:
 Both functions return a float and can be used directly in downstream analytics,
 visualisation or decision-making pipelines."""
 
+import re
+from pathlib import Path
 
 
 def read_source_lines(file_path: str, line: int, count: int = 5) -> str:
     """Return up to `count` source lines starting at the given 1-based line number."""
-    from pathlib import Path
     try:
         all_lines = Path(file_path).read_text(encoding="utf-8").splitlines()
         start = max(0, line - 1)
         return "\n".join(all_lines[start : start + count])
-    except OSError:
+    except (OSError, ValueError):
         return ""
 
 
 def format_source_context(file: str, line: int | str, context: int = 3, count: int = 8) -> str:
-    """Return a fenced python code block for the source around `line`, or '' if unavailable."""
+    """Return a fenced python code block for the source around `line`, or '' if unavailable.
+
+    Stops before spilling into the next top-level ``def`` or ``class`` definition.
+    """
     if not isinstance(line, int):
         return ""
     context_start = max(1, line - context)
     raw_lines = read_source_lines(file, context_start, count=count).splitlines()
     if not raw_lines:
         return ""
-    src = "\n".join(f"{context_start + i}: {rline}" for i, rline in enumerate(raw_lines))
+    error_offset = line - context_start  # 0-based index of the error line in raw_lines
+    collected = []
+    for i, rline in enumerate(raw_lines):
+        if i > error_offset and (
+            rline.startswith("def ")
+            or rline.startswith("async def ")
+            or rline.startswith("class ")
+        ):
+            break
+        collected.append(f"{context_start + i}: {rline}")
+    src = "\n".join(collected)
     return f"\n```python\n{src}\n```"
 
 
+_PYTHON_KEYWORDS = frozenset([
+    "if", "elif", "else", "for", "while", "with", "assert", "return",
+    "raise", "import", "from", "class", "def", "lambda", "yield",
+    "del", "pass", "break", "continue", "not", "and", "or", "in", "is",
+    "print", "super", "type", "len", "range",
+])
+
+
+def extract_callee_name(source_line: str) -> str | None:
+    """Extract the primary callee function name from a source line, or None.
+
+    Prefers the RHS of an assignment so that ``result = func(...)`` returns
+    ``func`` rather than the variable on the left.  Python keywords and
+    built-ins listed in ``_PYTHON_KEYWORDS`` are excluded.
+    """
+    stripped = source_line.strip()
+    rhs = stripped
+    if "=" in stripped and not stripped.startswith(("assert", "return")):
+        rhs = stripped.split("=", 1)[1].strip()
+    m = re.search(r"\b([a-zA-Z_]\w*)\s*\(", rhs)
+    if m and m.group(1) not in _PYTHON_KEYWORDS:
+        return m.group(1)
+    return None
+
+
+def _find_project_root(hint_file: str) -> Path:
+    root = Path(hint_file).resolve().parent
+    current = root
+    for _ in range(8):
+        if (current / "pyproject.toml").exists() or (current / "setup.py").exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return root
+
+
+def find_in_project(func_name: str, hint_file: str, max_lines: int = 10) -> tuple[str, str]:
+    """Find func_name definition in project files; same file first, then project-wide.
+
+    Returns ``(file_path, code_block)`` for the first match, or ``("", "")`` if not found.
+    """
+    result = find_function_source(hint_file, func_name, max_lines=max_lines)
+    if result:
+        return hint_file, result
+    root = _find_project_root(hint_file)
+    for py_file in sorted(root.rglob("*.py")):
+        if py_file.resolve() == Path(hint_file).resolve():
+            continue
+        r = find_function_source(str(py_file), func_name, max_lines=max_lines)
+        if r:
+            return str(py_file), r
+    return "", ""
+
+
+def _relative_path(path: str) -> str:
+    """Return path relative to cwd, normalised to forward slashes."""
+    try:
+        return str(Path(path).relative_to(Path.cwd())).replace("\\", "/")
+    except ValueError:
+        return path.replace("\\", "/")
+
+
+def format_callee_context(func_name: str, hint_file: str, max_lines: int = 10) -> str:
+    """Return a labelled callee definition block, or '' if not found in project.
+
+    Output format::
+
+        Callee `func_name` — `relative/path/to/file.py`
+        ```python
+        N: def func_name(...):
+        ...
+        ```
+    """
+    callee_file, code_block = find_in_project(func_name, hint_file, max_lines=max_lines)
+    if not code_block:
+        return ""
+    m = re.search(r"```python\n(\d+):", code_block)
+    line_ref = f":{m.group(1)}" if m else ""
+    return f"\n`{func_name}` is defined at: `{_relative_path(callee_file)}{line_ref}`{code_block}"
+
+
 def find_function_source(file: str, func_name: str, max_lines: int = 15) -> str:
     """Return a fenced python block for the body of func_name, or '' if unavailable."""
-    from pathlib import Path
     try:
         all_lines = Path(file).read_text(encoding="utf-8").splitlines()
-    except OSError:
+    except (OSError, ValueError):
         return ""
-    import re
     pattern = re.compile(rf"^(\s*)(?:async\s+)?def\s+{re.escape(func_name)}\s*\(")
     match_result: tuple[int, int] | None = None
     for i, line in enumerate(all_lines):
@@ -64,6 +159,8 @@ def find_function_source(file: str, func_name: str, max_lines: int = 15) -> str:
         collected.append(line)
         if len(collected) >= max_lines:
             break
+    while collected and not collected[-1].strip():
+        collected.pop()
     numbered = "\n".join(f"{start_idx + 1 + i}: {ln}" for i, ln in enumerate(collected))
     return f"\n```python\n{numbered}\n```"
 

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/compileparser.py

@@ -64,7 +64,10 @@ class CompileParser(AbstractParser):
                     compilations += 1
                 elif line.startswith("***   File "):
                     # This indicates a compilation error
-                    file_path = line.split('"')[1]
+                    parts = line.split('"')
+                    if len(parts) < 2:
+                        continue
+                    file_path = parts[1]
                     current_error = {"file": file_path, "error": line}
                 elif current_error and line.strip():
                     # Append additional error context
@@ -80,17 +83,21 @@ class CompileParser(AbstractParser):
                     error_info = {}
                     # Extract line number if present
                     if "line " in error_lines[0]:
-                        error_info["line"] = int(
-                            error_lines[0].split("line ")[1].split(",")[0]
-                        )
+                        try:
+                            error_info["line"] = int(
+                                error_lines[0].split("line ")[1].split(",")[0]
+                            )
+                        except ValueError:
+                            pass
                     # Get source code context if available
                     if len(error_lines) > 1:
                         error_info["src"] = error_lines[1].strip()
                     if len(error_lines) > 3:
                         if "Error:" in error_lines[3]:
                             error_parts = error_lines[3].split(":")
+                            type_tokens = error_parts[0].strip().split()
                             error_info["type"] = (
-                                error_parts[0].strip().split()[-1]
+                                type_tokens[-1] if type_tokens else "Unknown"
                             )  # Gets "SyntaxError"
                             error_info["help"] = ",".join(
                                 error_parts[1:]
@@ -125,4 +132,11 @@ class CompileParser(AbstractParser):
         typ = info.get("type", "Error")
         help_msg = info.get("help", "")
         code_block = format_source_context(file, line, count=context_lines) or (f"\n```python\n{info['src']}\n```" if info.get("src") else "")
-        return f"`{file}:{line}` — **{typ}**: {help_msg}{code_block}"
+        callee = ""
+        src_line = info.get("src", "")
+        if src_line:
+            from py_cq.parsers.common import extract_callee_name, format_callee_context
+            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}"

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/complexityparser.py

@@ -64,7 +64,14 @@ class ComplexityParser(AbstractParser):
             >>> result.metrics["simplicity"]
             0.4"""
         tr = ToolResult(raw=raw_result)
-        data = json.loads(raw_result.stdout)
+        try:
+            data = json.loads(raw_result.stdout)
+        except (json.JSONDecodeError, ValueError):
+            tr.metrics["simplicity"] = 0.0
+            return tr
+        if not isinstance(data, dict):
+            tr.metrics["simplicity"] = 0.0
+            return tr
         score = 0
         num_items = 0
         max_complexity = 30

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/coverageparser.py

@@ -76,13 +76,13 @@ class CoverageParser(AbstractParser):
         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"],
+            key=lambda x: x[1].get("coverage", 0.0),
         )[: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"]
+            pct = data.get("coverage", 0.0)
+            miss = data.get("missing", 0)
             lines.append(f"- `{path}`: {pct:.0%} ({miss} uncovered statements)")
         return "\n".join(lines)

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/halsteadparser.py

@@ -59,6 +59,14 @@ 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)
+        try:
+            data = json.loads(raw_result.stdout)
+        except (json.JSONDecodeError, ValueError):
+            tr.metrics = {"file_bug_free": 1.0, "file_smallness": 1.0, "functions_bug_free": 1.0, "functions_smallness": 1.0}
+            return tr
+        if not isinstance(data, dict):
+            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_FUNCTION_BUGS = 0.2
@@ -67,7 +75,6 @@ class HalsteadParser(AbstractParser):
         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:

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/interrogateparser.py

@@ -45,14 +45,14 @@ class InterrogateParser(AbstractParser):
     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"],
+            [(f, d) for f, d in tr.details.items() if isinstance(d, dict) and d.get("missing", 0) > 0],
+            key=lambda x: x[1].get("coverage", 0.0),
         )[:5]
         if not uncovered:
             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"]
+            miss = data.get("missing", 0)
+            pct = data.get("coverage", 0.0)
             lines.append(f"- `{path}`: {pct:.0%} ({miss} undocumented)")
         return "\n".join(lines)

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/maintainabilityparser.py

@@ -41,7 +41,14 @@ 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)
+        try:
+            data = json.loads(raw_result.stdout)
+        except (json.JSONDecodeError, ValueError):
+            tr.metrics["maintainability"] = 0.0
+            return tr
+        if not isinstance(data, dict):
+            tr.metrics["maintainability"] = 0.0
+            return tr
         num_items = 0
         score = 0
         for file, values in data.items():

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/pytestparser.py

@@ -13,6 +13,58 @@ import re as _re
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
 
 
+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.
+
+    Captures both indented context lines and pytest's ``>``-prefixed
+    current-executing-line marker.
+    """
+    lines = stdout.splitlines()
+    pattern = _re.compile(rf"_{{4,}}\s+{_re.escape(test_name)}\s+_{{4,}}")
+    in_section = False
+    last_src = ""
+    for line in lines:
+        if not in_section:
+            if pattern.search(line):
+                in_section = True
+        else:
+            stripped = line.strip()
+            if stripped.startswith(("_", "=")):
+                break
+            if stripped.startswith("E ") or stripped == "E":
+                break
+            if line.startswith(("    ", "\t", ">")):
+                src = line.lstrip("> \t")
+                if src:
+                    last_src = src
+    return last_src
+
+
+_COLLECTION_FILE_RE = _re.compile(r'E\s+File "([^"]+)", line (\d+)')
+_COLLECTION_ERROR_RE = _re.compile(r"E\s+(\w+(?:Error|Warning|Exception)):\s*(.*)")
+
+
+def _extract_collection_error(stdout: str) -> dict | None:
+    """Return {file, line, type, help} if pytest stdout contains a collection error."""
+    file_match = None
+    error_match = None
+    for line in stdout.splitlines():
+        m = _COLLECTION_FILE_RE.search(line)
+        if m:
+            file_match = m
+        m = _COLLECTION_ERROR_RE.search(line)
+        if m:
+            error_match = m
+    if file_match and error_match:
+        return {
+            "file": file_match.group(1).replace("\\", "/"),
+            "line": int(file_match.group(2)),
+            "type": error_match.group(1),
+            "help": error_match.group(2).strip(),
+        }
+    return 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()
@@ -102,8 +154,12 @@ class PytestParser(AbstractParser):
         return tr
 
     def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
-        """Return the first failing test with function body and failure output."""
-        from py_cq.parsers.common import find_function_source
+        """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
@@ -111,13 +167,22 @@ class PytestParser(AbstractParser):
                 if status != "FAILED":
                     continue
                 header = f"`{file}::{test_name}` — test **FAILED**"
-                body = find_function_source(file, test_name, max_lines=context_lines)
+                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)
+                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)
                 parts = [header]
                 if body:
                     parts.append(body)
                 if failure:
                     parts.append(failure)
+                if callee:
+                    parts.append(callee)
                 return "\n".join(parts)
         if "no tests ran" in tr.raw.stdout:
             return (
@@ -125,7 +190,29 @@ class PytestParser(AbstractParser):
                 "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."
             )
-        output = (tr.raw.stdout + tr.raw.stderr).strip()
+        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"]
+            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
+            src_line = ""
+            for ln in (tr.raw.stdout + tr.raw.stderr).splitlines():
+                m = _re.match(r"E\s{6,}(\S.*)", ln)
+                if m:
+                    src_line = m.group(1)
+            if src_line:
+                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}"
+        output = combined.strip()
         if output:
             tail = "\n".join(output.splitlines()[-30:])
             return f"pytest reported failures:\n\n```\n{tail}\n```"

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/ruffparser.py

@@ -50,7 +50,11 @@ class RuffParser(AbstractParser):
         if not tr.details:
             return "ruff reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
+        if not isinstance(issues, list) or not issues:
+            return "ruff reported issues (no details available)"
         issue = issues[0]
+        if not isinstance(issue, dict):
+            return "ruff reported issues (no details available)"
         line = issue.get("line", "?")
         code = issue.get("code", "")
         message = issue.get("message", "")

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/typarser.py

@@ -18,6 +18,16 @@ from py_cq.parsers.common import format_source_context, score_logistic_variant
 
 _DIAG_RE = re.compile(r"^(.+):(\d+):\d+:\s+(error|warning)\[([^\]]+)\] (.+)$")
 
+_CALL_CODES = frozenset([
+    "call-non-callable",
+    "missing-argument",
+    "unexpected-keyword",
+    "argument-type",
+    "too-many-positional-arguments",
+    "invalid-argument-type",
+    "no-matching-overload",
+])
+
 
 class TyParser(AbstractParser):
     """Parses raw output from ``ty check`` into a structured ToolResult."""
@@ -54,8 +64,20 @@ class TyParser(AbstractParser):
         if not tr.details:
             return "ty reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
+        if not isinstance(issues, list) or not issues:
+            return "ty reported issues (no details available)"
         issue = issues[0]
+        if not isinstance(issue, dict):
+            return "ty reported issues (no details available)"
         line = issue.get("line", "?")
         code = issue.get("code", "")
         message = issue.get("message", "")
-        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line, count=context_lines)}"
+        src_ctx = format_source_context(file, line, count=context_lines)
+        callee = ""
+        if code in _CALL_CODES and isinstance(line, int):
+            from py_cq.parsers.common import extract_callee_name, format_callee_context, read_source_lines
+            src_line = read_source_lines(file, line, count=1)
+            func_name = extract_callee_name(src_line)
+            if func_name:
+                callee = format_callee_context(func_name, file)
+        return f"`{file}:{line}` — **{code}**: {message}{src_ctx}{callee}"

{python_code_quality-0.1.14 → python_code_quality-0.1.16}/src/py_cq/parsers/vultureparser.py

@@ -40,7 +40,11 @@ class VultureParser(AbstractParser):
         if not tr.details:
             return "vulture reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
+        if not isinstance(issues, list) or not issues:
+            return "vulture reported issues (no details available)"
         issue = issues[0]
+        if not isinstance(issue, dict):
+            return "vulture reported issues (no details available)"
         line = issue.get("line", "?")
         kind = issue.get("type", "unused")
         name = issue.get("name", "")

python_code_quality-0.1.16/src/py_cq/table_formatter.py

@@ -0,0 +1,29 @@
+"""Rich table formatter for combined tool results."""
+
+from rich.table import Table
+
+from py_cq.localtypes import CombinedToolResults, ToolConfig
+
+
+def format_as_table(data: CombinedToolResults, registry: dict[str, ToolConfig]) -> Table:
+    """Format combined tool results into a Rich Table."""
+    table = Table(width=80)
+    table.add_column("Tool", justify="left", no_wrap=True)
+    table.add_column("Time", justify="right", style="dim")
+    table.add_column("Metric", justify="right", style="cyan", no_wrap=True)
+    table.add_column("Score", style="magenta")
+    table.add_column("Status")
+    for tr in data.tool_results:
+        tool_name = tr.raw.tool_name
+        config = next((t for t in registry.values() if t.name == tool_name))
+        for i, (name, value) in enumerate(tr.metrics.items()):
+            if value < config.error_threshold:
+                status = "[bold red]Error[/]"
+            elif value < config.warning_threshold:
+                status = "[yellow]Warning[/]"
+            else:
+                status = "[green]OK[/]"
+            time_str = f"{tr.duration_s:.2f}s" if i == 0 else ""
+            table.add_row(tool_name, time_str, name, f"{value:0.3f}", status)
+    table.add_row("", "", "[bold]Score[/]", f"[bold]{data.score:0.3f}[/]", "")
+    return table