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

py_cq/__init__.py

@@ -4,7 +4,3 @@ The module defines a single function, `hello`, which returns the string
 `'Hello from py_cq!'`. It can serve as a minimal example, placeholder, or
 testing stub in larger applications."""
 
-
-def hello() -> str:
-    """Returns the greeting string `'Hello from py_cq!'`."""
-    return "Hello from py_cq!"

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
@@ -84,6 +85,7 @@ def _apply_user_config(base: dict[str, ToolConfig], user_cfg: dict) -> dict[str,
                 run_in_target_env=tool_data.get("run_in_target_env", False),
                 extra_deps=tool_data.get("extra_deps", []),
                 parser_config=tool_data.get("parser_config", {}),
+                exclude_format=tool_data.get("exclude_format", ""),
             )
         except KeyError as e:
             raise typer.BadParameter(f"[tool.cq.tools.{tool_id}] missing required field {e}")
@@ -99,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()
 
@@ -131,6 +161,9 @@ def check(
     skip: str | None = typer.Option(
         None, "--skip", help="Comma-separated tool IDs to skip (e.g. bandit,vulture)"
     ),
+    exclude: str | None = typer.Option(
+        None, "--exclude", help="Comma-separated paths to exclude (e.g. demo,docs)"
+    ),
 ):
     """Feed the results from 11+ code quality tools to an LLM. Try: cq check . -o llm""" # --help
     path_obj = Path(path)
@@ -165,9 +198,12 @@ def check(
     if skip:
         drop = set(skip.split(","))
         effective_registry = {k: v for k, v in effective_registry.items() if k not in drop}
+    config_excludes: list[str] = user_cfg.get("exclude", [])
+    cli_excludes: list[str] = [e.strip() for e in exclude.split(",")] if exclude else []
+    excludes = list(dict.fromkeys(config_excludes + cli_excludes))
     if clear_cache:
         tool_cache.clear()
-    tool_results = run_tools(effective_registry.values(), path, workers, early_exit=(output == OutputMode.LLM))
+    tool_results = run_tools(effective_registry.values(), path, workers, early_exit=(output == OutputMode.LLM), excludes=excludes)
     # for tr in tool_results:
     #     log.debug(json.dumps(tr.to_dict(), indent=2))
     combined_metrics = aggregate_metrics(path=path, metrics=tool_results)

py_cq/config/config.yaml

@@ -8,14 +8,16 @@ python:
     error_threshold: 0.9999
 
   ruff:
-    command: "{python} -m ruff check --output-format concise --no-cache \"{context_path}\""
+    command: "{python} -m ruff check --output-format concise --no-cache \"{context_path}\"{exclude}"
+    exclude_format: " --exclude {path}"
     parser: "RuffParser"
     order: 2
     warning_threshold: 0.9999
     error_threshold: 0.9
 
   ty:
-    command: "{python} -m ty check --output-format concise --color never \"{context_path}\""
+    command: "{python} -m ty check --output-format concise --color never \"{context_path}\"{exclude}"
+    exclude_format: " --exclude {path}"
     parser: "TyParser"
     order: 3
     warning_threshold: 0.9999
@@ -25,14 +27,16 @@ python:
       - ty
 
   bandit:
-    command: "{python} -m bandit -r \"{context_path}\" -f json -q -s B101 --severity-level medium --exclude \"{input_path_posix}/.venv,{input_path_posix}/tests\""
+    command: "{python} -m bandit -r \"{context_path}\" -f json -q -s B101 --severity-level medium --exclude \"{input_path_posix}/.venv,{input_path_posix}/tests{exclude}\""
+    exclude_format: ",{input_path_posix}/{path}"
     parser: "BanditParser"
     order: 4
     warning_threshold: 0.9999
     error_threshold: 0.8
 
   pytest:
-    command: "{python} -m pytest -v \"{context_path}\""
+    command: "{python} -m pytest -v \"{context_path}\"{exclude}"
+    exclude_format: " --ignore {path}"
     parser: "PytestParser"
     order: 5
     warning_threshold: 1.0
@@ -74,14 +78,16 @@ python:
     error_threshold: 0.3
 
   vulture:
-    command: "{python} -m vulture \"{context_path}\" --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git"
+    command: "{python} -m vulture \"{context_path}\" --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git{exclude}"
+    exclude_format: ",{path}"
     parser: "VultureParser"
     order: 10
     warning_threshold: 0.9999
     error_threshold: 0.8
 
   interrogate:
-    command: "{python} -m interrogate \"{context_path}\" -v --fail-under 0"
+    command: "{python} -m interrogate \"{context_path}\" -e tests{exclude} -v --fail-under 0"
+    exclude_format: " -e {path}"
     parser: "InterrogateParser"
     order: 11
     warning_threshold: 0.8

py_cq/execution_engine.py

@@ -53,7 +53,17 @@ def _dep_in_venv(dep: str, project_root: Path) -> bool:
     return False
 
 
-def run_tool(tool_config: ToolConfig, context_path: str) -> RawResult:
+def _build_exclude_str(exclude_format: str, excludes: list[str], **extra_vars: str) -> str:
+    if not exclude_format or not excludes:
+        return ""
+    parts = []
+    for exc in excludes:
+        abs_posix_path = Path(exc).resolve().as_posix()
+        parts.append(exclude_format.format(path=exc, abs_posix_path=abs_posix_path, **extra_vars))
+    return "".join(parts)
+
+
+def run_tool(tool_config: ToolConfig, context_path: str, excludes: list[str] | None = None) -> RawResult:
     """Runs a tool defined by its configuration and returns the execution result.
 
     Args:
@@ -72,7 +82,7 @@ def run_tool(tool_config: ToolConfig, context_path: str) -> RawResult:
         >>> result.return_code
         0"""
     python = sys.executable
-    path = context_path
+    path = str(Path(context_path))
     if tool_config.run_in_target_env:
         uv = shutil.which("uv")
         if uv:
@@ -87,10 +97,12 @@ def run_tool(tool_config: ToolConfig, context_path: str) -> RawResult:
             project_root_path = Path(abs_dir)
             missing_deps = [d for d in tool_config.extra_deps if not _dep_in_venv(d, project_root_path)]
             with_flags = " ".join(f"--with {dep}" for dep in missing_deps)
-            python = f'"{uv}" run --directory "{abs_dir}" {with_flags}'.rstrip()
+            no_sync = "--no-sync" if sys.executable.startswith(abs_dir) else ""
+            python = f'"{uv}" run {no_sync} --directory "{abs_dir}" {with_flags}'.strip()
     abs_context_path = str(Path(context_path).resolve())
     input_path_posix = Path(context_path).as_posix().rstrip("/")
-    command = tool_config.command.format(context_path=path, abs_context_path=abs_context_path, input_path_posix=input_path_posix, python=python)
+    exclude = _build_exclude_str(tool_config.exclude_format, excludes or [], input_path_posix=input_path_posix)
+    command = tool_config.command.format(context_path=path, abs_context_path=abs_context_path, input_path_posix=input_path_posix, python=python, exclude=exclude)
     cache_key = f"{command}:{get_context_hash(context_path)}"
     if cache_key in _cache:
         log.info(f"Cache hit: {command}")
@@ -110,7 +122,7 @@ def run_tool(tool_config: ToolConfig, context_path: str) -> RawResult:
     return raw_result
 
 
-def run_tools(tool_configs: Collection[ToolConfig], path: str, max_workers: int = 0, early_exit: bool = False) -> list[ToolResult]:
+def run_tools(tool_configs: Collection[ToolConfig], path: str, max_workers: int = 0, early_exit: bool = False, excludes: list[str] | None = None) -> list[ToolResult]:
     """Run multiple tools and return their parsed results.
 
     Runs each tool specified in *tool_configs* on the file or directory at
@@ -152,7 +164,7 @@ def run_tools(tool_configs: Collection[ToolConfig], path: str, max_workers: int
         >>> results = run_tools(configs, '/path/to/project', parallel=True)"""
     def _run_and_parse(tool_config: ToolConfig) -> tuple[int, ToolResult]:
         t0 = time.perf_counter()
-        raw_result = run_tool(tool_config, path)
+        raw_result = run_tool(tool_config, path, excludes)
         tr = tool_config.parser_class(tool_config.parser_config).parse(raw_result)
         tr.duration_s = time.perf_counter() - t0
         return tool_config.order, tr

py_cq/localtypes.py

@@ -22,6 +22,7 @@ class ToolConfig:
     run_in_target_env: bool = False  # If True, run in target project's env via uv
     extra_deps: list[str] = field(default_factory=list)  # Extra deps to inject via uv --with
     parser_config: dict[str, Any] = field(default_factory=dict)
+    exclude_format: str = ""  # Per-path template for --exclude injection, e.g. " --exclude {path}"
 
 
 @dataclass

py_cq/parsers/__init__.py

@@ -0,0 +1 @@
+"""Tool Response parsers"""

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/interrogateparser.py

@@ -3,8 +3,8 @@
 Interrogate is invoked with ``-v --fail-under 0``, producing a table of
 per-file docstring coverage on stdout::
 
-    | src/foo.py  |  5 |  2 |  60% |
-    | TOTAL       |  5 |  2 |  60% |
+    | src/foo.py  |  5 |  2 |  3 |  60% |
+    | 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).
@@ -14,7 +14,7 @@ import re
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
 
-_ROW_RE = re.compile(r"^\|\s+(.+?)\s+\|\s+(\d+)\s+\|\s+(\d+)\s+\|\s+(\d+)%\s+\|")
+_ROW_RE = re.compile(r"^\|\s+(.+?)\s+\|\s+(\d+)\s+\|\s+(\d+)\s+\|\s+\d+\s+\|\s+(\d+(?:\.\d+)?)%\s*\|")
 
 
 class InterrogateParser(AbstractParser):
@@ -30,7 +30,7 @@ class InterrogateParser(AbstractParser):
             name = m.group(1).strip()
             total = int(m.group(2))
             miss = int(m.group(3))
-            cover = int(m.group(4))
+            cover = float(m.group(4))
             if name == "TOTAL":
                 total_coverage = cover / 100.0
             elif total > 0:

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

py_cq/tool_registry.py

@@ -30,6 +30,7 @@ def load_tool_configs() -> dict[str, ToolConfig]:
             run_in_target_env=tool_data.get("run_in_target_env", False),
             extra_deps=tool_data.get("extra_deps", []),
             parser_config=tool_data.get("parser_config", {}),
+            exclude_format=tool_data.get("exclude_format", ""),
         )
     return registry
 

{python_code_quality-0.1.13.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.13
+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>
@@ -35,39 +35,19 @@ Description-Content-Type: text/markdown
 [![Python versions](https://img.shields.io/pypi/pyversions/python-code-quality?)](https://pypi.org/project/python-code-quality/)
 [![License](https://img.shields.io/github/license/rhiza-fr/py-cq)](LICENSE)
 
-Feed the results from 11+ code quality tools to an LLM. Minimal tokens.
+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.
 
-Why? It removes the mental burden of understanding all these tools and parsing their results.
+This can dramatically reduce the amount of noise for LLMs (and humans) and remove the need for them to know about these tools.
 
-The primary workflow is:
+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
-# get the single most critical defect as markdown
-cq check . -o llm
-```
-
-```python
-`data/problems/travelling_salesman/ts_bad.py:21` — **F841**: Local variable `unused_variable` is assigned to but never used
-
-18:     min_dist = float("inf")
-19:     nearest_city = None
-20:     for city in cities:
-21:         unused_variable = 67
-22:         dist = calc_dist(current_city, city)
-23:         if dist < min_dist:
-24:             min_dist = dist
-25:             nearest_city = city
-
-Please fix only this issue. After fixing, run `cq check . -o llm` to verify.
-```
-Feed to an LLM with edit tools and repeat until there are no issues, e.g.
-
-```python
-cq check . -o llm | claude -p "fix this"
-# or
-cq check . -o llm | ollama run gpt-oss:20b "Explain how to fix this"
+cq check . -o llm     # top defect as markdown, pipe to an LLM
+cq check .            # table overview of all scores
+cq check . -o score   # numeric score only, exits 1 on errors (CI gate)
 ```
 
+![cq demo](demo/output/demo.gif)
 
 ## Install
 
@@ -114,6 +94,7 @@ cq check . -o raw          # Raw tool output for debug
 cq check path/to/file.py   # Just one file (skips pytest and coverage)
 cq check . --only ruff,ty  # Run only specific tools
 cq check . --skip bandit   # Skip specific tools
+cq check . --exclude demo  # Exclude paths from all tools
 cq check . --workers 1     # Run sequentially if you like things slow
 cq check . --clear-cache   # Clear cached results before running (rarely needed)
 cq config path/to/project/ # Show effective tool configuration
@@ -133,10 +114,17 @@ Add a stop hook to your project's `.claude/settings.json` so Claude automaticall
 ```json
 {
   "hooks": {
-    "Stop": [{
-      "matcher": "",
-      "hooks": [{"type": "command", "command": "cq check . -o score && echo 'CQ: all clear' || cq check . -o llm"}]
-    }]
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "cq check . -o score && echo 'CQ: all clear' || cq check . -o llm; true"
+          }
+        ]
+      }
+    ]
   }
 }
 ```
@@ -191,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
 ```
 
@@ -252,6 +240,9 @@ Add a `[tool.cq]` section to your project's `pyproject.toml`:
 # Skip tools that are slow or not relevant to your project
 disable = ["coverage", "interrogate"]
 
+# Exclude paths from all tools (merged with --exclude CLI flag)
+exclude = ["demo", "docs"]
+
 # Lines of source context shown around each defect in LLM output (default: 15)
 context_lines = 15
 
@@ -270,21 +261,23 @@ Tool IDs match the keys in `config/config.yaml`: `compile`, `ruff`, `ty`, `bandi
 python:
 
   compile:
-    command: "{python} -m compileall -r 10 -j 8 {context_path} -x .*venv"
+    command: "{python} -m compileall -r 10 -j 8 \"{context_path}\" -x .*venv"
     parser: "CompileParser"
     order: 1
     warning_threshold: 0.9999
     error_threshold: 0.9999
 
   ruff:
-    command: "{python} -m ruff check --output-format concise --no-cache {context_path}"
+    command: "{python} -m ruff check --output-format concise --no-cache \"{context_path}\"{exclude}"
+    exclude_format: " --exclude {path}"
     parser: "RuffParser"
     order: 2
     warning_threshold: 0.9999
     error_threshold: 0.9
 
   ty:
-    command: "{python} -m ty check --output-format concise --color never {context_path}"
+    command: "{python} -m ty check --output-format concise --color never \"{context_path}\"{exclude}"
+    exclude_format: " --exclude {path}"
     parser: "TyParser"
     order: 3
     warning_threshold: 0.9999
@@ -294,22 +287,26 @@ python:
       - ty
 
   bandit:
-    command: "{python} -m bandit -r {context_path} -f json -q -s B101 --severity-level medium --exclude {input_path_posix}/.venv,{input_path_posix}/tests"
+    command: "{python} -m bandit -r \"{context_path}\" -f json -q -s B101 --severity-level medium --exclude \"{input_path_posix}/.venv,{input_path_posix}/tests{exclude}\""
+    exclude_format: ",{input_path_posix}/{path}"
     parser: "BanditParser"
     order: 4
     warning_threshold: 0.9999
     error_threshold: 0.8
 
   pytest:
-    command: "{python} -m pytest -v {context_path}"
+    command: "{python} -m pytest -v \"{context_path}\"{exclude}"
+    exclude_format: " --ignore {path}"
     parser: "PytestParser"
     order: 5
     warning_threshold: 1.0
     error_threshold: 1.0
     run_in_target_env: true
+    extra_deps:
+      - pytest
 
   coverage:
-    command: "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest {context_path} && {python} -m coverage report --omit=*/tests/*,*/test_*.py"
+    command: "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest \"{context_path}\" && {python} -m coverage report --omit=*/tests/*,*/test_*.py"
     parser: "CoverageParser"
     order: 6
     warning_threshold: 0.9
@@ -320,40 +317,41 @@ python:
       - pytest
 
   radon-cc:
-    command: "{python} -m radon cc --json {context_path}"
+    command: "{python} -m radon cc --json \"{context_path}\""
     parser: "ComplexityParser"
     order: 7
     warning_threshold: 0.6
     error_threshold: 0.4
 
   radon-mi:
-    command: "{python} -m radon mi -s --json {context_path}"
+    command: "{python} -m radon mi -s --json \"{context_path}\""
     parser: "MaintainabilityParser"
     order: 8
     warning_threshold: 0.6
     error_threshold: 0.4
 
   radon-hal:
-    command: "{python} -m radon hal -f --json {context_path}"
+    command: "{python} -m radon hal -f --json \"{context_path}\""
     parser: "HalsteadParser"
     order: 9
     warning_threshold: 0.5
     error_threshold: 0.3
 
   vulture:
-    command: "{python} -m vulture {context_path} --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git"
+    command: "{python} -m vulture \"{context_path}\" --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git{exclude}"
+    exclude_format: ",{path}"
     parser: "VultureParser"
     order: 10
     warning_threshold: 0.9999
     error_threshold: 0.8
 
   interrogate:
-    command: "{python} -m interrogate {context_path} -v --fail-under 0"
+    command: "{python} -m interrogate \"{context_path}\" -e tests{exclude} -v --fail-under 0"
+    exclude_format: " -e {path}"
     parser: "InterrogateParser"
     order: 11
     warning_threshold: 0.8
     error_threshold: 0.3
-
 ```
 
 ## Respect

{python_code_quality-0.1.13.dist-info → python_code_quality-0.1.15.dist-info}/RECORD

@@ -1,33 +1,33 @@
-py_cq/__init__.py,sha256=rS7kf1RU1zZskvJlkbZaMqEpdRYPspwDPAFbxzF3tXg,373
-py_cq/cli.py,sha256=x4BZTZVFTbSCqcdvF17Ed_WEJ5n3aQtODL7mLHzF_3s,11528
+py_cq/__init__.py,sha256=U2ysDtSFdv2mlXZz4w1Q42pfgfi6YY_3Ln24bkZq14I,260
+py_cq/cli.py,sha256=HWTMtA9Gfn3YeO7B94kter6HNNSzPjyX1HLJQ1eNBvU,12936
 py_cq/config/__init__.py,sha256=f0wc51O_3kGDTZUnCbGv8_zWnC5yYGl4NWcf2buSImQ,670
-py_cq/config/config.yaml,sha256=R8CjZH8erBQSbJFKgHt-CCwD1Mgj6ZCGQ3OtWH0Ebig,2402
+py_cq/config/config.yaml,sha256=TPZJogpWbyf0Ml2mHrHzTNyTik3k07KPVGsA1wT9GEc,2696
 py_cq/context_hash.py,sha256=h-i7Rhd7AUfLv9SkQvE79bjJvTsm_ZwoVwSmUKXWmfM,2977
-py_cq/execution_engine.py,sha256=lA9HAX5iIxxIaOjTNxSak1qZUuETGKlNdsOMAdY2sQo,8012
+py_cq/execution_engine.py,sha256=nAsCvldUfDagZnfOwXf4A37VQLxCGiv12T8ymutflC4,8697
 py_cq/language_detector.py,sha256=6av5HaimcZ54RkN69xQmGgC0mxtTvGzPV3SL8NGG8Uc,1116
 py_cq/llm_formatter.py,sha256=l74O5iqNWMR16789Xncoi93xOqgQJhW5IQK9_OyA9mE,1632
-py_cq/localtypes.py,sha256=jCX1ZuwTixQooEk2N1Gi1XRuDcdBc2NlOdQBKysEybk,6128
+py_cq/localtypes.py,sha256=UGI2kl1xB2TedKGByth3URiqJKY56YZMNds1hnLEzvU,6228
 py_cq/main.py,sha256=VKoXI8R8rB2fEROBYoTVURfinLqyh8XTNIIWAOtH7dw,380
 py_cq/metric_aggregator.py,sha256=M2ymo62S7p7qPUqjjoiPg4IVyXQhLMuTr9-jxLiFjCY,853
-py_cq/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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
 py_cq/parsers/halsteadparser.py,sha256=ZCN7LP1iUZ91tf3tlspKAPQrTEa78XVdE9Fjn9yPvYk,9008
-py_cq/parsers/interrogateparser.py,sha256=G07beMaGR0Mq-pGVozAbwK0xOx9MdMaNVGq2CGrUb7w,2225
+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=oMEkFHkU3gg5UpeGD4zHtynOYmWieRgDN5kTwZ5KsE8,1584
-python_code_quality-0.1.13.dist-info/WHEEL,sha256=M4DeIjVCA49okfALADZoWX5JOGwnmHb-JOpQHtI-1c0,80
-python_code_quality-0.1.13.dist-info/entry_points.txt,sha256=cfWbTw7eYO6Trv1-Z_odL6Zta9CqYU6Vk9lAHdfB60Q,40
-python_code_quality-0.1.13.dist-info/METADATA,sha256=jxjtkNG-hBU_o6lXwddPF_ZIXrMFEwd9FrLc4l0Cwz8,12463
-python_code_quality-0.1.13.dist-info/RECORD,,
+py_cq/tool_registry.py,sha256=UfmwJH8rtmTY9kX02QaE4OJIWyboTMcXUavgb9R4fxc,1648
+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,,