python-code-quality 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

py_cq/cli.py

@@ -16,6 +16,7 @@ import json
 import logging
 import tomllib
 from enum import Enum
+from importlib import import_module
 from pathlib import Path
 
 import typer
@@ -26,6 +27,7 @@ from rich.table import Table
 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.metric_aggregator import aggregate_metrics
 from py_cq.tool_registry import tool_registry
@@ -56,6 +58,7 @@ def _apply_user_config(base: dict[str, ToolConfig], user_cfg: dict) -> dict[str,
     Supports:
       - ``disable``: list of tool IDs to remove
       - ``thresholds.<tool_id>.warning`` / ``.error``: override per-tool thresholds
+      - ``tools.<tool_id>``: declare new tools (or override built-ins)
     """
     registry = {k: copy.copy(v) for k, v in base.items()}
     for tool_id in user_cfg.get("disable", []):
@@ -66,6 +69,24 @@ def _apply_user_config(base: dict[str, ToolConfig], user_cfg: dict) -> dict[str,
                 registry[tool_id].warning_threshold = float(thresholds["warning"])
             if "error" in thresholds:
                 registry[tool_id].error_threshold = float(thresholds["error"])
+    for tool_id, tool_data in user_cfg.get("tools", {}).items():
+        try:
+            parser_name = tool_data["parser"]
+            module = import_module(f"py_cq.parsers.{parser_name.lower()}")
+            parser_class = getattr(module, parser_name)
+            registry[tool_id] = ToolConfig(
+                name=tool_id,
+                command=tool_data["command"],
+                parser_class=parser_class,
+                order=tool_data["order"],
+                warning_threshold=tool_data["warning_threshold"],
+                error_threshold=tool_data["error_threshold"],
+                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", {}),
+            )
+        except KeyError as e:
+            raise typer.BadParameter(f"[tool.cq.tools.{tool_id}] missing required field {e}")
     return registry
 
 
@@ -101,11 +122,27 @@ def check(
     workers: int = typer.Option(
         0, "--workers", help="Max parallel workers (default: one per tool, use 1 for sequential)"
     ),
+    language: str | None = typer.Option(
+        None, "--language", "-l", help="Override language detection (e.g. python, typescript, rust)"
+    ),
 ):
     """Feed the results from 11+ code quality tools to an LLM. Try: cq check . -o llm""" # --help
     path_obj = Path(path)
     if not path_obj.exists():
         raise typer.BadParameter(f"Path does not exist: {path}")
+
+    resolved_language = language or detect_language(path_obj)
+
+    if resolved_language is not None and resolved_language != "python":
+        console.print(
+            f"[yellow]{resolved_language.capitalize()} project detected. "
+            "Non-Python language support is not yet available.[/yellow]"
+        )
+        raise typer.Exit(0)
+
+    # Python path (or unknown — fall through to existing validation).
+    # Note: --language python still requires pyproject.toml; the flag selects
+    # the tool set, not the input validation rules.
     if path_obj.is_file():
         if path_obj.suffix != ".py":
             raise typer.BadParameter(f"File must be a Python file (.py): {path}")
@@ -113,7 +150,9 @@ def check(
         if not (path_obj / "pyproject.toml").exists():
             raise typer.BadParameter(f"Directory must contain pyproject.toml: {path}")
     log.setLevel(log_level)
-    effective_registry = _apply_user_config(tool_registry, load_user_config(path_obj))
+    user_cfg = load_user_config(path_obj)
+    context_lines: int = int(user_cfg.get("context_lines", 15))
+    effective_registry = _apply_user_config(tool_registry, user_cfg)
     if clear_cache:
         tool_cache.clear()
     tool_results = run_tools(effective_registry.values(), path, workers, early_exit=(output == OutputMode.LLM))
@@ -129,10 +168,19 @@ 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))
+        console.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))
 
+    tool_by_name = {tc.name: tc for tc in effective_registry.values()}
+    if any(
+        min(tr.metrics.values()) < tool_by_name[tr.raw.tool_name].error_threshold
+        for tr in tool_results
+        if tr.metrics and tr.raw.tool_name in tool_by_name
+    ):
+        raise typer.Exit(code=1)
+
 
 @app.command()
 def config(
@@ -172,8 +220,9 @@ def config(
     table.add_column("Error", justify="right")
     table.add_column("Status", justify="center")
 
-    for tool_id in sorted(tool_registry, key=lambda t: tool_registry[t].order):
-        tc = effective_registry.get(tool_id, tool_registry[tool_id])
+    all_tool_ids = set(tool_registry) | set(effective_registry)
+    for tool_id in sorted(all_tool_ids, key=lambda t: (effective_registry.get(t) or tool_registry[t]).order):
+        tc = effective_registry.get(tool_id) or tool_registry[tool_id]
         is_disabled = tool_id in disabled_ids
         status = "[red]disabled[/red]" if is_disabled else "[green]enabled[/green]"
         table.add_row(
@@ -204,7 +253,7 @@ def format_as_table(data: CombinedToolResults, registry: dict[str, ToolConfig]):
         >>> table = format_as_table(combined_results)
         >>> console.print(table)
     """
-    table = Table(title=f"[bold green]{data.path}[/]", width=80)
+    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)

py_cq/config/{tools.yaml → config.yaml}

@@ -1,52 +1,48 @@
-tools:
+python:
 
-  compilation:
-    name: "compile"
-    command: "{python} -m compileall -r 10 -j 8 {context_path} -x .*venv"
+  compile:
+    command: "{python} -m compileall -r 10 -j 8 \"{context_path}\" -x .*venv"
     parser: "CompileParser"
     order: 1
     warning_threshold: 0.9999
     error_threshold: 0.9999
 
-  bandit:
-    name: "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"
-    parser: "BanditParser"
-    order: 2
-    warning_threshold: 0.9999
-    error_threshold: 0.8
-
   ruff:
-    name: "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}\""
     parser: "RuffParser"
-    order: 3
+    order: 2
     warning_threshold: 0.9999
     error_threshold: 0.9
 
   ty:
-    name: "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}\""
     parser: "TyParser"
-    order: 4
+    order: 3
     warning_threshold: 0.9999
     error_threshold: 0.8
     run_in_target_env: true
     extra_deps:
       - 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\""
+    parser: "BanditParser"
+    order: 4
+    warning_threshold: 0.9999
+    error_threshold: 0.8
+
   pytest:
-    name: "pytest"
-    command: "{python} -m pytest -v {context_path}"
+    command: "{python} -m pytest -v \"{context_path}\""
     parser: "PytestParser"
     order: 5
-    warning_threshold: 0.7
-    error_threshold: 0.5
+    warning_threshold: 1.0
+    error_threshold: 1.0
     run_in_target_env: true
+    extra_deps:
+      - pytest
 
   coverage:
-    name: "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
@@ -56,41 +52,36 @@ tools:
       - coverage
       - pytest
 
-  complexity:
-    name: "radon cc"
-    command: "{python} -m radon cc --json {context_path}"
+  radon-cc:
+    command: "{python} -m radon cc --json \"{context_path}\""
     parser: "ComplexityParser"
     order: 7
     warning_threshold: 0.6
     error_threshold: 0.4
 
-  maintainability:
-    name: "radon mi"
-    command: "{python} -m radon mi -s --json {context_path}"
+  radon-mi:
+    command: "{python} -m radon mi -s --json \"{context_path}\""
     parser: "MaintainabilityParser"
     order: 8
     warning_threshold: 0.6
     error_threshold: 0.4
 
-  halstead:
-    name: "radon hal"
-    command: "{python} -m radon hal -f --json {context_path}"
+  radon-hal:
+    command: "{python} -m radon hal -f --json \"{context_path}\""
     parser: "HalsteadParser"
     order: 9
     warning_threshold: 0.5
     error_threshold: 0.3
 
   vulture:
-    name: "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"
     parser: "VultureParser"
     order: 10
     warning_threshold: 0.9999
     error_threshold: 0.8
 
   interrogate:
-    name: "interrogate"
-    command: "{python} -m interrogate {context_path} -v --fail-under 0"
+    command: "{python} -m interrogate \"{context_path}\" -v --fail-under 0"
     parser: "InterrogateParser"
     order: 11
     warning_threshold: 0.8

py_cq/execution_engine.py

@@ -82,7 +82,7 @@ def run_tool(tool_config: ToolConfig, context_path: str) -> RawResult:
         log.info(f"Cache hit: {command}")
         return RawResult(**cast(dict[str, Any], _cache[cache_key]))
     log.info(f"Running: {command}")
-    result = subprocess.run(command, capture_output=True, text=True, shell=True) # nosec
+    result = subprocess.run(command, capture_output=True, text=True, shell=True, encoding="utf-8", errors="replace") # nosec
     timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
     raw_result = RawResult(
         tool_name=tool_config.name,
@@ -139,7 +139,7 @@ def run_tools(tool_configs: Collection[ToolConfig], path: str, max_workers: int
     def _run_and_parse(tool_config: ToolConfig) -> tuple[int, ToolResult]:
         t0 = time.perf_counter()
         raw_result = run_tool(tool_config, path)
-        tr = tool_config.parser_class().parse(raw_result)
+        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/language_detector.py

@@ -0,0 +1,29 @@
+"""Detect the primary language of a project from its file markers."""
+
+from pathlib import Path
+
+# Ordered: first match wins. Python is listed first so it takes priority.
+_MARKERS: list[tuple[str, list[str]]] = [
+    ("python", ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile"]),
+    ("typescript", ["tsconfig.json", "package.json"]),
+    ("rust", ["Cargo.toml"]),
+    ("go", ["go.mod"]),
+    ("ruby", ["Gemfile"]),
+    ("java", ["pom.xml", "build.gradle"]),
+]
+
+_DOTNET_SUFFIXES = {".csproj", ".sln"}
+
+
+def detect_language(path: Path) -> str | None:
+    """Return the detected language for a project path, or None if unrecognised.
+
+    If path is a file, the parent directory is checked.
+    Dotnet is checked last as it uses suffix matching rather than fixed filenames."""
+    directory = path if path.is_dir() else path.parent
+    for language, markers in _MARKERS:
+        if any((directory / marker).exists() for marker in markers):
+            return language
+    if any(f.suffix in _DOTNET_SUFFIXES for f in directory.iterdir() if f.is_file()):
+        return "dotnet"
+    return None

py_cq/llm_formatter.py

@@ -18,6 +18,7 @@ def format_for_llm(
     tool_configs: dict,
     combined: CombinedToolResults,
     cq_invocation: str | None = None,
+    context_lines: int = 15,
 ) -> str:
     """Return a markdown prompt describing the single most important defect."""
     by_name = {tc.name: tc for tc in tool_configs.values()}
@@ -38,7 +39,7 @@ def format_for_llm(
 
     worst = failing[0]
     config = by_name[worst.raw.tool_name]
-    defect_md = config.parser_class().format_llm_message(worst)
+    defect_md = config.parser_class().format_llm_message(worst, context_lines=context_lines)
     if cq_invocation is None:
         cq_invocation = "cq " + " ".join(sys.argv[1:])
     return (

py_cq/localtypes.py

@@ -21,6 +21,7 @@ class ToolConfig:
     error_threshold: float = 0.5  # Red error if below this
     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)
 
 
 @dataclass
@@ -119,12 +120,15 @@ class AbstractParser(ABC):
 
     Subclasses must implement `parse` to convert a `RawResult` into a `ToolResult`. An optional `provide_help` can be overridden to supply contextual guidance for a parsed result."""
 
+    def __init__(self, parser_config: dict | None = None):
+        self.parser_config = parser_config or {}
+
     @abstractmethod
     def parse(self, raw_result: RawResult) -> ToolResult:
         """Converts raw tool output into a structured ToolResult."""
         pass
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return a single-defect description for LLM consumption.
 
         Default implementation reports the worst metric by name and score.

py_cq/parsers/banditparser.py

@@ -42,7 +42,7 @@ class BanditParser(AbstractParser):
         score = score_logistic_variant(weighted, scale_factor=10)
         return ToolResult(raw=raw_result, metrics={"security": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         if not tr.details:
             return "bandit reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
@@ -51,4 +51,4 @@ class BanditParser(AbstractParser):
         code = issue.get("code", "")
         severity = issue.get("severity", "")
         message = issue.get("message", "")
-        return f"`{file}:{line}` — **{code}** [{severity}]: {message}{format_source_context(file, line)}"
+        return f"`{file}:{line}` — **{code}** [{severity}]: {message}{format_source_context(file, line, count=context_lines)}"

py_cq/parsers/common.py

@@ -37,6 +37,37 @@ def format_source_context(file: str, line: int | str, context: int = 3, count: i
     return f"\n```python\n{src}\n```"
 
 
+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:
+        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):
+        m = pattern.match(line)
+        if m:
+            match_result = (i, len(m.group(1)))
+            break
+    if match_result is None:
+        return ""
+    start_idx, baseline_indent = match_result
+    collected = [all_lines[start_idx]]
+    for line in all_lines[start_idx + 1 :]:
+        stripped = line.lstrip()
+        indent = len(line) - len(stripped)
+        if stripped and indent <= baseline_indent:
+            break
+        collected.append(line)
+        if len(collected) >= max_lines:
+            break
+    numbered = "\n".join(f"{start_idx + 1 + i}: {ln}" for i, ln in enumerate(collected))
+    return f"\n```python\n{numbered}\n```"
+
+
 def inv_normalize(value: float, max_value: float) -> float:
     """Returns the inverse normalized value of `value` relative to `max_value`."""
     return (max_value - min(value, max_value)) / max_value

py_cq/parsers/compileparser.py

@@ -115,7 +115,7 @@ class CompileParser(AbstractParser):
             tr.details["failed_files"] = failed_files
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the first compilation failure as a defect description."""
         failed = tr.details.get("failed_files", {})
         if not failed:
@@ -124,5 +124,5 @@ class CompileParser(AbstractParser):
         line = info.get("line", "?")
         typ = info.get("type", "Error")
         help_msg = info.get("help", "")
-        code_block = format_source_context(file, line) or (f"\n```python\n{info['src']}\n```" if info.get("src") else "")
+        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}"

py_cq/parsers/coverageparser.py

@@ -71,7 +71,7 @@ class CoverageParser(AbstractParser):
         tr.details = details
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    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(

py_cq/parsers/exitcodeparser.py

@@ -0,0 +1,16 @@
+"""Parser that scores a tool pass/fail based solely on its exit code."""
+
+from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+
+
+class ExitCodeParser(AbstractParser):
+    """Score 1.0 if the tool exited with code 0, else 0.0."""
+
+    def parse(self, raw_result: RawResult) -> ToolResult:
+        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:
+        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)"

py_cq/parsers/halsteadparser.py

@@ -113,7 +113,7 @@ class HalsteadParser(AbstractParser):
         }
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the worst Halstead offender as an actionable defect description."""
         if not tr.metrics:
             return "No Halstead details available"

py_cq/parsers/interrogateparser.py

@@ -42,7 +42,7 @@ class InterrogateParser(AbstractParser):
         score = total_coverage if total_coverage is not None else 1.0
         return ToolResult(raw=raw_result, metrics={"doc_coverage": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    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],

py_cq/parsers/linecountparser.py

@@ -0,0 +1,26 @@
+"""Parser that scores a tool by counting non-empty output lines as violations."""
+
+from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+from py_cq.parsers.common import score_logistic_variant
+
+
+class LineCountParser(AbstractParser):
+    """Score based on number of non-empty stdout lines.
+
+    parser_config keys:
+        scale_factor (int, default 15): passed to score_logistic_variant.
+    """
+
+    def parse(self, raw_result: RawResult) -> ToolResult:
+        lines = [ln for ln in (raw_result.stdout or "").splitlines() if ln.strip()]
+        count = len(lines)
+        scale = self.parser_config.get("scale_factor", 15)
+        score = score_logistic_variant(count, scale_factor=scale)
+        return ToolResult(raw=raw_result, metrics={"violations": score}, details={"lines": lines})
+
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+        lines = tr.details.get("lines", [])
+        if not lines:
+            return "No violations found"
+        shown = lines[:context_lines]
+        return "\n".join(shown)

py_cq/parsers/pytestparser.py

@@ -8,11 +8,33 @@ process return code so downstream components can uniformly consume results
 from multiple test tools.  It is part of the test-collection framework and
 enables consistent handling of pytest output across the system."""
 
-import re
+import re as _re
 
 from py_cq.localtypes import AbstractParser, RawResult, ToolResult
 
 
+def _extract_failure(stdout: str, test_name: str, max_lines: int) -> str:
+    """Extract the failure section for test_name from pytest stdout."""
+    lines = stdout.splitlines()
+    pattern = _re.compile(rf"_{{4,}}\s+{_re.escape(test_name)}\s+_{{4,}}")
+    start = None
+    for i, line in enumerate(lines):
+        if pattern.search(line):
+            start = i + 1
+            break
+    if start is None:
+        return ""
+    collected = []
+    for line in lines[start:]:
+        if line.strip().startswith("_") or line.strip().startswith("="):
+            break
+        collected.append(line)
+        if len(collected) >= max_lines:
+            break
+    text = "\n".join(collected).strip()
+    return f"\n```\n{text}\n```" if text else ""
+
+
 class PytestParser(AbstractParser):
     """Parses raw pytest output into a structured `ToolResult`.
 
@@ -51,14 +73,14 @@ class PytestParser(AbstractParser):
         lines = raw_result.stdout.splitlines()
         tr = ToolResult(raw=raw_result)
         if "no tests ran" in raw_result.stdout:
-            pass
+            tr.metrics["tests"] = 0.0
         else:
             tests_found = dict()
             num_tests = 0
             passed_tests = 0
             for line in lines:
                 # tests/test_common.py::test_name[param] PASSED    [ 8%]
-                tests_match = re.search(r"(.*\.py)::([\w\[\].,+\- ]+) (PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)", line)
+                tests_match = _re.search(r"(.*\.py)::([\w\[\].,+\- ]+) (PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)", line)
                 if tests_match:
                     test_file = tests_match.group(1)
                     test_name = tests_match.group(2).strip()
@@ -70,7 +92,7 @@ class PytestParser(AbstractParser):
             if num_tests == 0:
                 # No individual test lines found (e.g. non-verbose output);
                 # fall back to parsing the pytest summary line.
-                summary = re.search(r"(\d+) passed(?:.*?(\d+) failed)?", raw_result.stdout)
+                summary = _re.search(r"(\d+) passed(?:.*?(\d+) failed)?", raw_result.stdout)
                 if summary:
                     passed_tests = int(summary.group(1))
                     failed_tests = int(summary.group(2)) if summary.group(2) else 0
@@ -79,11 +101,32 @@ class PytestParser(AbstractParser):
             tr.details = tests_found
         return tr
 
-    def format_llm_message(self, tr: ToolResult) -> str:
-        """Return the first failing test as a defect description."""
+    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
         for file, tests in tr.details.items():
-            if isinstance(tests, dict):
-                for test_name, status in tests.items():
-                    if status == "FAILED":
-                        return f"`{file}::{test_name}` — test **FAILED**"
+            if not isinstance(tests, dict):
+                continue
+            for test_name, status in tests.items():
+                if status != "FAILED":
+                    continue
+                header = f"`{file}::{test_name}` — test **FAILED**"
+                body = find_function_source(file, test_name, max_lines=context_lines)
+                failure = _extract_failure(tr.raw.stdout, test_name, max_lines=context_lines)
+                parts = [header]
+                if body:
+                    parts.append(body)
+                if failure:
+                    parts.append(failure)
+                return "\n".join(parts)
+        if "no tests ran" in tr.raw.stdout:
+            return (
+                "**No tests found.** This project has no pytest test suite.\n\n"
+                "Add a `tests/` directory with at least one test file (e.g. `tests/test_basic.py`) "
+                "and write a first test covering a core function."
+            )
+        output = (tr.raw.stdout + tr.raw.stderr).strip()
+        if output:
+            tail = "\n".join(output.splitlines()[-30:])
+            return f"pytest reported failures:\n\n```\n{tail}\n```"
         return "pytest reported failures (no details available)"

py_cq/parsers/regexcountparser.py

@@ -0,0 +1,35 @@
+"""Parser that counts stdout lines matching a regex pattern."""
+
+import re
+
+from py_cq.localtypes import AbstractParser, RawResult, ToolResult
+from py_cq.parsers.common import score_logistic_variant
+
+
+class RegexCountParser(AbstractParser):
+    """Score based on the number of stdout lines matching a regex.
+
+    parser_config keys:
+        pattern (str, required): regex pattern to match against each line.
+        scale_factor (int, default 15): passed to score_logistic_variant.
+    """
+
+    def parse(self, raw_result: RawResult) -> ToolResult:
+        pattern = re.compile(self.parser_config["pattern"])
+        scale = self.parser_config.get("scale_factor", 15)
+        lines = (raw_result.stdout or "").splitlines()
+        matches = [ln for ln in lines if pattern.search(ln)]
+        count = len(matches)
+        score = score_logistic_variant(count, scale_factor=scale)
+        return ToolResult(
+            raw=raw_result,
+            metrics={"violations": score},
+            details={"count": count, "matches": matches},
+        )
+
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
+        matches = tr.details.get("matches", [])
+        if not matches:
+            return "No violations found"
+        shown = matches[:context_lines]
+        return "\n".join(shown)

py_cq/parsers/ruffparser.py

@@ -45,7 +45,7 @@ class RuffParser(AbstractParser):
         )
         return ToolResult(raw=raw_result, metrics={"lint": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the first lint violation as a defect description."""
         if not tr.details:
             return "ruff reported issues (no details available)"
@@ -54,4 +54,4 @@ class RuffParser(AbstractParser):
         line = issue.get("line", "?")
         code = issue.get("code", "")
         message = issue.get("message", "")
-        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line)}"
+        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line, count=context_lines)}"

py_cq/parsers/typarser.py

@@ -49,7 +49,7 @@ class TyParser(AbstractParser):
         score = score_logistic_variant(weighted, scale_factor=10)
         return ToolResult(raw=raw_result, metrics={"type_check": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         """Return the first type-check diagnostic as a defect description."""
         if not tr.details:
             return "ty reported issues (no details available)"
@@ -58,4 +58,4 @@ 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)}"
+        return f"`{file}:{line}` — **{code}**: {message}{format_source_context(file, line, count=context_lines)}"

py_cq/parsers/vultureparser.py

@@ -36,7 +36,7 @@ class VultureParser(AbstractParser):
         score = score_logistic_variant(count, scale_factor=15)
         return ToolResult(raw=raw_result, metrics={"dead_code": score}, details=files)
 
-    def format_llm_message(self, tr: ToolResult) -> str:
+    def format_llm_message(self, tr: ToolResult, *, context_lines: int = 15) -> str:
         if not tr.details:
             return "vulture reported issues (no details available)"
         file, issues = next(iter(tr.details.items()))
@@ -45,4 +45,4 @@ class VultureParser(AbstractParser):
         kind = issue.get("type", "unused")
         name = issue.get("name", "")
         confidence = issue.get("confidence", "?")
-        return f"`{file}:{line}` — **{kind}** `{name}` ({confidence}% confidence){format_source_context(file, line)}"
+        return f"`{file}:{line}` — **{kind}** `{name}` ({confidence}% confidence){format_source_context(file, line, count=context_lines)}"

py_cq/tool_registry.py

@@ -9,19 +9,19 @@ from py_cq.localtypes import ToolConfig
 
 
 def load_tool_configs() -> dict[str, ToolConfig]:
-    """Load tool configurations from the bundled tools.yaml and return a registry.
+    """Load tool configurations from the bundled config.yaml and return a registry.
 
     Returns:
         dict[str, ToolConfig]: A mapping from tool ID to its configuration instance."""
-    yaml_text = files("py_cq.config").joinpath("tools.yaml").read_text(encoding="utf-8")
+    yaml_text = files("py_cq.config").joinpath("config.yaml").read_text(encoding="utf-8")
     config = yaml.safe_load(yaml_text)
     registry = {}
-    for tool_id, tool_data in config["tools"].items():
+    for tool_id, tool_data in config["python"].items():
         # Dynamically import parser class
         module = import_module(f"py_cq.parsers.{tool_data['parser'].lower()}")
         parser_class = getattr(module, tool_data["parser"])
         registry[tool_id] = ToolConfig(
-            name=tool_data["name"],
+            name=tool_id,
             command=tool_data["command"],
             parser_class=parser_class,
             order=tool_data["order"],
@@ -29,6 +29,7 @@ def load_tool_configs() -> dict[str, ToolConfig]:
             error_threshold=tool_data["error_threshold"],
             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", {}),
         )
     return registry
 

{python_code_quality-0.1.8.dist-info → python_code_quality-0.1.10.dist-info}/METADATA

@@ -1,20 +1,17 @@
 Metadata-Version: 2.4
 Name: python-code-quality
-Version: 0.1.8
+Version: 0.1.10
 Summary: Python Code Quality Analysis Tool - feed the results from 11 CQ tools straight into an LLM. Minimal tokens.
-Project-URL: Homepage, https://github.com/rhiza-fr/py-cq
-Project-URL: Repository, https://github.com/rhiza-fr/py-cq
+Author: Chris Kilner
 Author-email: Chris Kilner <chris@rhiza.fr>
 License-Expression: MIT
-License-File: LICENSE
-Requires-Python: >=3.12
 Requires-Dist: bandit>=1.8.0
 Requires-Dist: coverage>=7.8.2
 Requires-Dist: diskcache>=5.6.3
 Requires-Dist: interrogate>=1.7.0
+Requires-Dist: pytest>=8.4.0
 Requires-Dist: pytest-cov>=6.1.1
 Requires-Dist: pytest-json-report>=1.5.0
-Requires-Dist: pytest>=8.4.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: radon>=6.0.1
 Requires-Dist: rich>=14.0.0
@@ -22,26 +19,25 @@ Requires-Dist: ruff>=0.14.1
 Requires-Dist: ty>=0.0.17
 Requires-Dist: typer>=0.16.0
 Requires-Dist: vulture>=2.14
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/rhiza-fr/py-cq
+Project-URL: Repository, https://github.com/rhiza-fr/py-cq
 Description-Content-Type: text/markdown
 
 # CQ - Python Code Quality Analysis Tool
 
 Feed the results from 11+ code quality tools to an LLM. Minimal tokens.
 
+Why? It removes the mental burden of understanding all these tools and parsing their results.
+
 The primary workflow is:
 
 ```bash
 # get the single most critical defect as markdown
 cq check . -o llm
 ```
-Selects the single most critical defect using this priority order:
-
-1. **Severity** — tools with score below `error_threshold` come before those only below `warning_threshold`
-2. **Order** — among tools at the same severity, lower-order tools win (compile before lint before style)
-3. **Score** — among ties, the lower score wins
 
-The code context is expanded if available.
-```md
+```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")
@@ -60,9 +56,10 @@ 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 gpt-oss:20b "Explain how to fix this"
+cq check . -o llm | ollama run gpt-oss:20b "Explain how to fix this"
 ```
 
+
 ## Install
 
 ```bash
@@ -70,21 +67,22 @@ cq check . -o llm | ollama gpt-oss:20b "Explain how to fix this"
 uv tool install python-code-quality
 
 # or, clone it then install 
-git pull https://github.com/rhiza-fr/py-cq.git
+git clone https://github.com/rhiza-fr/py-cq.git
 cd py-cq
 uv tool install .
 ```
 
 ## Tools
 
-These tools are run in **parallel** except when looking for the first error in -o llm mode:
+These tools are run in **parallel** except:
+When running '-o llm', we run sequentially and exit early at the first error.
 
 | Order | Tool | Measures |
 |----------|------|----------|
 | 1 | compileall | Syntax errors |
-| 2 | bandit | Security vulnerabilities |
-| 3 | ruff | Lint / style |
-| 4 | ty | Type errors |
+| 2 | ruff | Lint / style |
+| 3 | ty | Type errors |
+| 4 | bandit | Security vulnerabilities |
 | 5 | pytest | Test pass rate |
 | 6 | coverage | Test coverage |
 | 7 | radon cc | Cyclomatic complexity |
@@ -93,14 +91,14 @@ These tools are run in **parallel** except when looking for the first error in -
 | 10 | vulture | Dead code |
 | 11 | interrogate | Docstring coverage |
 
-Diskcache is used to cache tool output for lightning fast re-runs. Sane defaults: <100 Mb, <5 days, No pickle
+Diskcache is used to cache tool output for lightning fast re-runs. Sane defaults: <100 Mb, <5 days, No pickle risk.
 
 
 ## Usage
 
 ```bash
 cq check .                 # Table overview of scores for humans
-cq check -o llm            # Top defect as markdown for LLMs
+cq check . -o llm          # Top defect as markdown for LLMs
 cq check . -o score        # Numeric score only for CI
 cq check . -o json         # Detailed parsed JSON output for jq
 cq check . -o raw          # Raw tool output for debug
@@ -110,6 +108,46 @@ cq check . --clear-cache   # Clear cached results before running (rarely needed)
 cq config path/to/project/ # Show effective tool configuration
 ```
 
+**Exit codes:** `cq check` exits with code `1` if any tool metric falls below its `error_threshold`, making it suitable as a CI gate:
+
+```bash
+cq check . && deploy        # block deploy on errors
+cq check . -o score         # print score, exit 1 on errors
+```
+
+## Claude Code Integration
+
+Add a stop hook to your project's `.claude/settings.json` so Claude automatically checks quality after each session and loops until clean:
+
+```json
+{
+  "hooks": {
+    "Stop": [{
+      "matcher": "",
+      "hooks": [{"type": "command", "command": "cq check . -o score && echo 'CQ: all clear' || cq check . -o llm"}]
+    }]
+  }
+}
+```
+
+When the score passes, Claude sees `CQ: all clear` (~5 tokens). When it fails, Claude receives the targeted fix prompt and continues working. This automates the `cq check . -o llm | claude -p "fix this"` loop.
+
+> **Note:** Use project-level `.claude/settings.json`, not global settings — this hook only makes sense in Python projects.
+
+### As a slash command (skill)
+
+For manual invocation, create `.claude/commands/cq-fix.md`:
+
+```markdown
+$(cq check . -o llm)
+```
+
+Then invoke it with `/cq-fix` in Claude Code. The `$(...)` embeds the live `cq` output directly into the prompt before Claude starts, so it sees the issue immediately without an extra tool call.
+
+**Hook vs skill:**
+- **Stop hook** — automatic, runs after every session, best for unattended loops
+- **Skill** — manual `/cq-fix`, gives you explicit control over when to check
+
 ## Table output
 
 ```bash
@@ -121,9 +159,9 @@ cq config path/to/project/ # Show effective tool configuration
 ┃ Tool             ┃     Time ┃                    Metric ┃ Score   ┃ Status   ┃
 ┡━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━┩
 │ compile          │    0.42s │                   compile │ 1.000   │ OK       │
-│ bandit           │    0.56s │                  security │ 1.000   │ OK       │
 │ ruff             │    0.17s │                      lint │ 1.000   │ OK       │
 │ ty               │    0.33s │                type_check │ 1.000   │ OK       │
+│ bandit           │    0.56s │                  security │ 1.000   │ OK       │
 │ pytest           │    0.91s │                     tests │ 1.000   │ OK       │
 │ coverage         │    1.26s │                  coverage │ 0.910   │ OK       │
 │ radon cc         │    0.32s │                simplicity │ 0.982   │ OK       │
@@ -167,7 +205,7 @@ cq config path/to/project/ # Show effective tool configuration
 
 ## Raw output
 ```bash
-> cq check -o raw
+> cq check . -o raw
 ```
 
 ```json
@@ -193,66 +231,63 @@ 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"]
 
+# Lines of source context shown around each defect in LLM output (default: 15)
+context_lines = 15
+
 # Override warning/error thresholds per tool
 [tool.cq.thresholds.coverage]
 warning = 0.9
 error = 0.7
 ```
 
-Tool IDs match the keys in `config/tools.yaml`: `compilation`, `bandit`, `ruff`, `ty`, `pytest`, `coverage`, `complexity`, `maintainability`, `halstead`, `vulture`, `interrogate`.
+Tool IDs match the keys in `config/config.yaml`: `compile`, `ruff`, `ty`, `bandit`, `pytest`, `coverage`, `radon-cc`, `radon-mi`, `radon-hal`, `vulture`, `interrogate`.
 
 
 ### Default config
 
 ```yaml
-tools:
+python:
 
-  compilation:
-    name: "compile"
+  compile:
     command: "{python} -m compileall -r 10 -j 8 {context_path} -x .*venv"
     parser: "CompileParser"
     order: 1
     warning_threshold: 0.9999
     error_threshold: 0.9999
 
-  bandit:
-    name: "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"
-    parser: "BanditParser"
-    order: 2
-    warning_threshold: 0.9999
-    error_threshold: 0.8
-
   ruff:
-    name: "ruff"
     command: "{python} -m ruff check --output-format concise --no-cache {context_path}"
     parser: "RuffParser"
-    order: 3
+    order: 2
     warning_threshold: 0.9999
     error_threshold: 0.9
 
   ty:
-    name: "ty"
     command: "{python} -m ty check --output-format concise --color never {context_path}"
     parser: "TyParser"
-    order: 4
+    order: 3
     warning_threshold: 0.9999
     error_threshold: 0.8
     run_in_target_env: true
     extra_deps:
       - 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"
+    parser: "BanditParser"
+    order: 4
+    warning_threshold: 0.9999
+    error_threshold: 0.8
+
   pytest:
-    name: "pytest"
     command: "{python} -m pytest -v {context_path}"
     parser: "PytestParser"
     order: 5
-    warning_threshold: 0.7
-    error_threshold: 0.5
+    warning_threshold: 1.0
+    error_threshold: 1.0
     run_in_target_env: true
 
   coverage:
-    name: "coverage"
     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
@@ -263,24 +298,21 @@ tools:
       - coverage
       - pytest
 
-  complexity:
-    name: "radon cc"
+  radon-cc:
     command: "{python} -m radon cc --json {context_path}"
     parser: "ComplexityParser"
     order: 7
     warning_threshold: 0.6
     error_threshold: 0.4
 
-  maintainability:
-    name: "radon mi"
+  radon-mi:
     command: "{python} -m radon mi -s --json {context_path}"
     parser: "MaintainabilityParser"
     order: 8
     warning_threshold: 0.6
     error_threshold: 0.4
 
-  halstead:
-    name: "radon hal"
+  radon-hal:
     command: "{python} -m radon hal -f --json {context_path}"
     parser: "HalsteadParser"
     order: 9
@@ -288,7 +320,6 @@ tools:
     error_threshold: 0.3
 
   vulture:
-    name: "vulture"
     command: "{python} -m vulture {context_path} --min-confidence 80 --exclude .venv,dist,.*_cache,docs,.git"
     parser: "VultureParser"
     order: 10
@@ -296,7 +327,6 @@ tools:
     error_threshold: 0.8
 
   interrogate:
-    name: "interrogate"
     command: "{python} -m interrogate {context_path} -v --fail-under 0"
     parser: "InterrogateParser"
     order: 11

python_code_quality-0.1.10.dist-info/RECORD

@@ -0,0 +1,33 @@
+py_cq/__init__.py,sha256=rS7kf1RU1zZskvJlkbZaMqEpdRYPspwDPAFbxzF3tXg,373
+py_cq/cli.py,sha256=wu1GlxSDxS835i9-mO4-xmyBLfr6puU-ES-26T7Mty0,11007
+py_cq/config/__init__.py,sha256=f0wc51O_3kGDTZUnCbGv8_zWnC5yYGl4NWcf2buSImQ,670
+py_cq/config/config.yaml,sha256=R8CjZH8erBQSbJFKgHt-CCwD1Mgj6ZCGQ3OtWH0Ebig,2402
+py_cq/context_hash.py,sha256=h-i7Rhd7AUfLv9SkQvE79bjJvTsm_ZwoVwSmUKXWmfM,2977
+py_cq/execution_engine.py,sha256=tgNGFOO3h-EyetCEzC_RS2K-b9OkOFpOwGwrEAHIpZA,7477
+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/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/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/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/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/regexcountparser.py,sha256=KSoNh2spucXU06pxxr2QW0LrPLfJkFMAsmSgjooaFv0,1316
+py_cq/parsers/ruffparser.py,sha256=ZdIya4sct2PrsOyfKfMGmXHLh3Qu7HtFqXNY9IuNFog,2275
+py_cq/parsers/typarser.py,sha256=zrI0KS65MUGPxYPP74B6BRyTbjcPhKyQPjH2KZIyxN0,2495
+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.10.dist-info/WHEEL,sha256=Y4JtJkdCWKLnDS7bvHXqjUWSsYTnJMN9TTubfHSxAyo,80
+python_code_quality-0.1.10.dist-info/entry_points.txt,sha256=cfWbTw7eYO6Trv1-Z_odL6Zta9CqYU6Vk9lAHdfB60Q,40
+python_code_quality-0.1.10.dist-info/METADATA,sha256=YSf-Gi84I-D8SWRe4tA5oS9AuH2nKLu6W88pVBUjO3Q,11358
+python_code_quality-0.1.10.dist-info/RECORD,,

{python_code_quality-0.1.8.dist-info → python_code_quality-0.1.10.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: uv 0.11.0
 Root-Is-Purelib: true
 Tag: py3-none-any

{python_code_quality-0.1.8.dist-info → python_code_quality-0.1.10.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 cq = py_cq.main:main
+

python_code_quality-0.1.8.dist-info/RECORD

@@ -1,30 +0,0 @@
-py_cq/__init__.py,sha256=rS7kf1RU1zZskvJlkbZaMqEpdRYPspwDPAFbxzF3tXg,373
-py_cq/cli.py,sha256=9rNdLdU2mcZVz3qdkczO4Rs_PU0-brZMmj5wJfv-Jcs,8688
-py_cq/context_hash.py,sha256=h-i7Rhd7AUfLv9SkQvE79bjJvTsm_ZwoVwSmUKXWmfM,2977
-py_cq/execution_engine.py,sha256=Q7Z8iibkE_E9VfkbUdnI_g5wA8GdwDbnJI4Mex-V8mE,7416
-py_cq/llm_formatter.py,sha256=EdUMhvsnPLplSSUKDknMHiaLdKsd9B6aH-tTdpxukdY,1574
-py_cq/localtypes.py,sha256=_PAx-F0cj03r_3YR1cyR9ilYYmYxUC14TkRtgLjH-Rc,5927
-py_cq/main.py,sha256=VKoXI8R8rB2fEROBYoTVURfinLqyh8XTNIIWAOtH7dw,380
-py_cq/metric_aggregator.py,sha256=M2ymo62S7p7qPUqjjoiPg4IVyXQhLMuTr9-jxLiFjCY,853
-py_cq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-py_cq/tool_registry.py,sha256=Ov5kQIRc5C5vkAq5Nc2Otp5kYiQzJuK5_nA-ZkY_-NQ,1529
-py_cq/config/__init__.py,sha256=f0wc51O_3kGDTZUnCbGv8_zWnC5yYGl4NWcf2buSImQ,670
-py_cq/config/tools.yaml,sha256=cNs4h4sIJA-j28QhEFG0uWL9ELaPy_z8BNo4l5F3is4,2553
-py_cq/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-py_cq/parsers/banditparser.py,sha256=vj23tTbipaeVkhS_ldWI7GrpHGwlIkOuaEgszkrjzh0,2277
-py_cq/parsers/common.py,sha256=lc9Chtr3H5l3vTk-vRVhptQVJfOeLax0UWTRjhA9IOU,4044
-py_cq/parsers/compileparser.py,sha256=mVY8qh1oZQ8n9GJLW2ruF9j89G5GuxWb7fb6JeogTJ4,6207
-py_cq/parsers/complexityparser.py,sha256=2t1-wmNjUu65fULcIm5jcgv7ZLWwjakyiY_r-Fx1QQg,3983
-py_cq/parsers/coverageparser.py,sha256=xDNlLNEsA0U3z4GV02iEq97IL90-UJAQrhMlFzpIdy0,4013
-py_cq/parsers/halsteadparser.py,sha256=9z_abpPPuclUQBgq4P6u2vIfIB7ZShX2NbFnubTatqI,8980
-py_cq/parsers/interrogateparser.py,sha256=eMROINtyZE2eHrRxVU0jA-nYTdvr0PZ8iERVn7kPH5o,2197
-py_cq/parsers/maintainabilityparser.py,sha256=Ax0ZFA6zzqYIWZH1hP1_GUtdVn2LIJ8SKWtqVNdszYs,3411
-py_cq/parsers/pytestparser.py,sha256=ERgS1aTTi7aB-Xk_Y9Xpo9h5jT9n0q3_vAfHCZwBTFE,4539
-py_cq/parsers/ruffparser.py,sha256=Wgch9rDkR-6tJlfhDfG1CXXEZu0Gfk0qRpsI3KzjCZU,2226
-py_cq/parsers/typarser.py,sha256=u7ktoH0TzmhB2saCJF1iY1LkfGui5ami2leLlYSCcns,2446
-py_cq/parsers/vultureparser.py,sha256=X2fen6yQu-r_zoRt1qKfIGlGZKORkHCiZE4BFlxtzdE,1946
-python_code_quality-0.1.8.dist-info/METADATA,sha256=2-E2SuWhsQMwYtv4NERKmE9CajsglC81tZY5DPPefrc,10266
-python_code_quality-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-python_code_quality-0.1.8.dist-info/entry_points.txt,sha256=j5Q_gGr0b7389lddt1JlZ7gcL4Z7RHxuDhij_G-IhBY,39
-python_code_quality-0.1.8.dist-info/licenses/LICENSE,sha256=Bpuh8tbf37so8M5NtRGTLmT5ue7diJ17223L9f9nsT0,1086
-python_code_quality-0.1.8.dist-info/RECORD,,

python_code_quality-0.1.8.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Chris Kilner <chris@rhiza.fr>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.