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

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
@@ -100,8 +101,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):  
+        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()
 

py_cq/parsers/common.py

@@ -12,6 +12,7 @@ performance metrics or error scores:
 Both functions return a float and can be used directly in downstream analytics,
 visualisation or decision-making pipelines."""
 
+from pathlib import Path
 
 
 def read_source_lines(file_path: str, line: int, count: int = 5) -> str:
@@ -26,17 +27,118 @@ def read_source_lines(file_path: str, line: int, count: int = 5) -> str:
 
 
 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.
+    """
+    import re
+    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:
+    from pathlib import 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.
+    """
+    from pathlib import Path
+    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."""
+    from pathlib import Path
+    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(...):
+        ...
+        ```
+    """
+    import re
+    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
@@ -64,6 +166,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```"
 

py_cq/parsers/compileparser.py

@@ -125,4 +125,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}"

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```"

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."""
@@ -58,4 +68,12 @@ class TyParser(AbstractParser):
         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.dist-info → python_code_quality-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-code-quality
-Version: 0.1.14
+Version: 0.1.15
 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.dist-info → python_code_quality-0.1.15.dist-info}/RECORD

@@ -1,5 +1,5 @@
 py_cq/__init__.py,sha256=U2ysDtSFdv2mlXZz4w1Q42pfgfi6YY_3Ln24bkZq14I,260
-py_cq/cli.py,sha256=RRQVPVOwG-EMYndMUhBfqBqm1S1kcaObhKOdfxrrYl0,11963
+py_cq/cli.py,sha256=HWTMtA9Gfn3YeO7B94kter6HNNSzPjyX1HLJQ1eNBvU,12936
 py_cq/config/__init__.py,sha256=f0wc51O_3kGDTZUnCbGv8_zWnC5yYGl4NWcf2buSImQ,670
 py_cq/config/config.yaml,sha256=TPZJogpWbyf0Ml2mHrHzTNyTik3k07KPVGsA1wT9GEc,2696
 py_cq/context_hash.py,sha256=h-i7Rhd7AUfLv9SkQvE79bjJvTsm_ZwoVwSmUKXWmfM,2977
@@ -11,8 +11,8 @@ py_cq/main.py,sha256=VKoXI8R8rB2fEROBYoTVURfinLqyh8XTNIIWAOtH7dw,380
 py_cq/metric_aggregator.py,sha256=M2ymo62S7p7qPUqjjoiPg4IVyXQhLMuTr9-jxLiFjCY,853
 py_cq/parsers/__init__.py,sha256=YS3wPS0cMNU80zkdSZBEZOkqDKE6Jk--0Xd_bX7VMcA,27
 py_cq/parsers/banditparser.py,sha256=Ju_CkuXtkVn1Th9aQ6mv6fTUTpb9pc1YD8Nzt_nMgFQ,2326
-py_cq/parsers/common.py,sha256=thbziNjqaf-SY3Y0W-KmPwzlcC-YCV98Z8jubUJM7_4,5203
-py_cq/parsers/compileparser.py,sha256=YsT7ePUDRjsUHTLqgRv4x6jJBCTt6cbm1mgxplzxETg,6256
+py_cq/parsers/common.py,sha256=h3-eLyi0YNkk-2ZiNUKxZhIFZNHUf01kyAqCtFbxNIY,8803
+py_cq/parsers/compileparser.py,sha256=EBoqZyPDkkfc9FssGkKrIATU6TDHSSB7xWeqrnOiMEc,6576
 py_cq/parsers/complexityparser.py,sha256=2t1-wmNjUu65fULcIm5jcgv7ZLWwjakyiY_r-Fx1QQg,3983
 py_cq/parsers/coverageparser.py,sha256=n4h_RCxKvJoYgp356PA4laAmFcngjQ41b_GXZvKkVgc,4041
 py_cq/parsers/exitcodeparser.py,sha256=ZFL3EbPhGvFjm2qZhfLD1_5dNjR9ULYNQpKgy0Z_dGo,729
@@ -20,14 +20,14 @@ py_cq/parsers/halsteadparser.py,sha256=ZCN7LP1iUZ91tf3tlspKAPQrTEa78XVdE9Fjn9yPv
 py_cq/parsers/interrogateparser.py,sha256=gk9pJ7yFXMzLjk6PP0X8fxW_gAE2DTIoWMsPqF2xIXs,2260
 py_cq/parsers/linecountparser.py,sha256=nxWvFntuR8T6FDGpafrlevvt-jR3rwkbVo_t2JX4TF0,1067
 py_cq/parsers/maintainabilityparser.py,sha256=Ax0ZFA6zzqYIWZH1hP1_GUtdVn2LIJ8SKWtqVNdszYs,3411
-py_cq/parsers/pytestparser.py,sha256=3N1X4wKhJ2h-2U1GuM3gHWHpHxU9f0LPGcPaojra9W4,6377
+py_cq/parsers/pytestparser.py,sha256=_seSfvAD_88A-yDyWYpLuIrLL2Wjp3rbcqG3fNCNEnA,9705
 py_cq/parsers/regexcountparser.py,sha256=KSoNh2spucXU06pxxr2QW0LrPLfJkFMAsmSgjooaFv0,1316
 py_cq/parsers/ruffparser.py,sha256=ZdIya4sct2PrsOyfKfMGmXHLh3Qu7HtFqXNY9IuNFog,2275
-py_cq/parsers/typarser.py,sha256=zrI0KS65MUGPxYPP74B6BRyTbjcPhKyQPjH2KZIyxN0,2495
+py_cq/parsers/typarser.py,sha256=oJWudNyRZw-r_-gr2nIzDfS7YJGpt5K3otk9E4G5Ldo,3140
 py_cq/parsers/vultureparser.py,sha256=U6zC7P0ATA_N4SB90BahKF5QHMITf_z-NsOgrh_Q5rA,1995
 py_cq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 py_cq/tool_registry.py,sha256=UfmwJH8rtmTY9kX02QaE4OJIWyboTMcXUavgb9R4fxc,1648
-python_code_quality-0.1.14.dist-info/WHEEL,sha256=M4DeIjVCA49okfALADZoWX5JOGwnmHb-JOpQHtI-1c0,80
-python_code_quality-0.1.14.dist-info/entry_points.txt,sha256=cfWbTw7eYO6Trv1-Z_odL6Zta9CqYU6Vk9lAHdfB60Q,40
-python_code_quality-0.1.14.dist-info/METADATA,sha256=HR_8B9uca6SBAn7f74rMAnTOJ6LzODc5AF0w0Uiic28,12496
-python_code_quality-0.1.14.dist-info/RECORD,,
+python_code_quality-0.1.15.dist-info/WHEEL,sha256=M4DeIjVCA49okfALADZoWX5JOGwnmHb-JOpQHtI-1c0,80
+python_code_quality-0.1.15.dist-info/entry_points.txt,sha256=cfWbTw7eYO6Trv1-Z_odL6Zta9CqYU6Vk9lAHdfB60Q,40
+python_code_quality-0.1.15.dist-info/METADATA,sha256=bh2Ex3HJZiNMiJ_LaVtOE_MHf497VN3s0xH8ISWHmvs,12749
+python_code_quality-0.1.15.dist-info/RECORD,,