python-code-quality 0.1.7__tar.gz → 0.1.9__tar.gz

python_code_quality-0.1.9/.gitea/workflows/python-multi-version-test.yaml

@@ -0,0 +1,65 @@
+# Template: Multi-version Python testing workflow for Gitea Actions
+# Copy this file to your project's .gitea/workflows/ directory
+#
+# Runs tests against multiple Python versions using generic ubuntu runners.
+# Includes optional dependency upgrade testing.
+
+name: Python Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.12', '3.13']
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Run tests
+        run: uv run pytest
+
+  # Optional: Test if dependencies can be upgraded
+  upgrade-test:
+    name: Dependency Upgrade Test
+    runs-on: ubuntu-latest
+    continue-on-error: true  # Don't fail the whole workflow if upgrades break
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'  # Test upgrades on latest Python
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Upgrade all dependencies
+        run: uv lock --upgrade
+
+      - name: Install upgraded dependencies
+        run: uv sync --all-extras
+
+      - name: Run tests with upgraded dependencies
+        run: uv run pytest

python_code_quality-0.1.9/.gitea/workflows/test.yaml

@@ -0,0 +1,11 @@
+name: Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: python-test-image
+    steps:
+      - uses: actions/checkout@v4
+      - run: uv sync --all-extras
+      - run: uv run pytest

{python_code_quality-0.1.7 → python_code_quality-0.1.9}/.gitignore

@@ -15,3 +15,4 @@ analysis_results.json
 .claude
 .cq.json
 
+docs/plans/*

{python_code_quality-0.1.7 → python_code_quality-0.1.9}/CLAUDE.md

@@ -11,7 +11,7 @@ cq check -o llm   # returns the single most critical defect as markdown
 ```
 
 The LLM fixes it, the user re-runs, and repeats until all tools pass. CQ runs
-11 static analysis tools in priority order (compile → security → lint → types →
+11 static analysis tools in execution order (compile → security → lint → types →
 tests → coverage → complexity → dead code → style) and aggregates results into
 a single score.
 
@@ -39,16 +39,16 @@ uv run ruff check src/
 **Pipeline flow:** CLI (`cli.py`) → tool registry → execution engine → parsers → metric aggregator → output
 
 - **`cli.py`**: Typer app with a single `check` command. Output mode selected via `--output`/`-o` enum (`table`, `score`, `json`, `llm`). Runs tools in parallel by default. Reads `[tool.cq]` from the target project's `pyproject.toml` and applies overrides before running.
-- **`tool_registry.py`**: Loads `src/cq/config/tools.yaml` at import time via `importlib.resources`, dynamically imports parser classes, builds a `dict[str, ToolConfig]` registry.
-- **`config/tools.yaml`** (at `src/cq/config/tools.yaml`): Declares each analysis tool: shell command template (with `{context_path}` placeholder), parser class name, priority, warning/error thresholds. Tools are listed and executed in priority order.
-- **`execution_engine.py`**: Runs shell commands via `subprocess.run`, caches results with `diskcache` using a content-based hash. Parallel execution via `ThreadPoolExecutor`; results are sorted by priority before returning.
+- **`tool_registry.py`**: Loads `src/cq/config/config.yaml` at import time via `importlib.resources`, dynamically imports parser classes, builds a `dict[str, ToolConfig]` registry.
+- **`config/config.yaml`** (at `src/cq/config/config.yaml`): Declares each analysis tool: shell command template (with `{context_path}` placeholder), parser class name, order, warning/error thresholds. Tools are listed and executed in order.
+- **`execution_engine.py`**: Runs shell commands via `subprocess.run`, caches results with `diskcache` using a content-based hash. Parallel execution via `ThreadPoolExecutor`; results are sorted by order before returning.
 - **`parsers/`**: Each parser subclasses `AbstractParser` (from `localtypes.py`), implementing `parse(RawResult) -> ToolResult` and optionally `format_llm_message(ToolResult) -> str`. Parser module names must match the lowercase parser class name (e.g., `PytestParser` → `pytestparser.py`).
 - **`localtypes.py`**: Core dataclasses — `ToolConfig`, `RawResult`, `ToolResult`, `CombinedToolResults`, and `AbstractParser` ABC.
 - **`metric_aggregator.py`**: Wraps results into `CombinedToolResults`, which computes an overall score as the average of per-tool mean metrics.
-- **`llm_formatter.py`**: Selects the worst-scoring tool by severity tier then priority, formats its top defect as markdown for LLM consumption.
+- **`llm_formatter.py`**: Selects the worst-scoring tool by severity tier then order, formats its top defect as markdown for LLM consumption.
 
 ## Adding a New Analysis Tool
 
-1. Add tool entry in `config/tools.yaml` with command template, parser name, priority, and thresholds.
+1. Add tool entry in `config/config.yaml` with command template, parser name, order, and thresholds.
 2. Create `src/cq/parsers/<parsername>.py` with a class matching the `parser` field in YAML.
 3. The parser must subclass `AbstractParser` and implement `parse(RawResult) -> ToolResult`.

{python_code_quality-0.1.7 → python_code_quality-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-code-quality
-Version: 0.1.7
+Version: 0.1.9
 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
@@ -28,14 +28,16 @@ Description-Content-Type: text/markdown
 
 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
 ```
-Outputs the top error from the first priority tool where the score < warning_threshold,. 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")
@@ -51,10 +53,13 @@ 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"
 ```
 
+
 ## Install
 
 ```bash
@@ -62,21 +67,22 @@ cq check . -o llm | claude -p "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**:
+These tools are run in **parallel** except:
+When running '-o llm', we run sequentially and exit early at the first error.
 
-| Priority | Tool | Measures |
+| 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 |
@@ -85,37 +91,28 @@ These tools are run in **parallel**:
 | 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
-# LLM workflow: get the top defect as markdown (primary use case)
-cq check -o llm
-
-# Rich table with all metrics
-cq check .
-
-# Numeric score only — useful in CI or scripts
-cq check . -o score
-
-# Full JSON output, including raw test results
-cq check . -o json
-
-# Explicit path
-cq check path/to/project/
-cq check path/to/file.py
-
-# Run sequentially if you like things slow
-cq check . --workers 1
+cq check .                 # Table overview of scores for humans
+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
+cq check path/to/file.py   # Just one file (skips pytest and coverage)
+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
+```
 
-# Clear cached results before running (rarely needed)
-cq check . --clear-cache
+**Exit codes:** `cq check` exits with code `1` if any tool metric falls below its `error_threshold`, making it suitable as a CI gate:
 
-# Show effective tool configuration (thresholds, enabled/disabled status)
-cq config
-cq config path/to/project/
+```bash
+cq check . && deploy        # block deploy on errors
+cq check . -o score         # print score, exit 1 on errors
 ```
 
 ## Table output
@@ -129,9 +126,9 @@ cq config path/to/project/
 ┃ 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       │
@@ -160,30 +157,36 @@ cq config path/to/project/
 ```
 
 ```json
-{
-  "metrics": [
-    {
-      "metrics": {
-        "compile": 1.0
-      },
-      "details": {},
-      "raw": {
-        "tool_name": "compile",
-        "command": ".venv\\Scripts\\python.exe -m compileall -r 10 -j 8 . -x .*venv",
-        "stdout": "Compiling './src/project/file.py'...",
-        "stderr": "",
-        "return_code": 0,
-        "timestamp": "2026-02-19 05:03:11"
-      },
-      "duration_s": 0.08294440002646297
+[
+  {
+    "tool_name": "compile",
+    "metrics": {
+      "compile": 1.0
     },
-    {
-      "metrics": {
-        "security": 1.0
-      }
-      // many more lines ...
-    }
-]}
+    "details": {},
+    "duration_s": 0.05611889995634556
+  }
+  ...
+]
+```
+
+## Raw output
+```bash
+> cq check . -o raw
+```
+
+```json
+[
+  {
+    "tool_name": "compile",
+    "command": "D:\\ai\\py-cq\\.venv\\Scripts\\python.exe -m compileall -r 10 -j 8 . -x .*venv",
+    "stdout": "",
+    "stderr": "",
+    "return_code": 0,
+    "timestamp": "2026-02-20 10:01:22"
+  }
+  ...
+]
 ```
 
 ## Configuration
@@ -195,69 +198,66 @@ 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"
-    priority: 1
+    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"
-    priority: 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"
-    priority: 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"
-    priority: 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"
-    priority: 5
-    warning_threshold: 0.7
-    error_threshold: 0.5
+    order: 5
+    warning_threshold: 1.0
+    error_threshold: 1.0
     run_in_target_env: true
 
   coverage:
-    name: "coverage"
-    command: "{python} -m coverage run -m pytest {context_path} && {python} -m coverage report"
+    command: "{python} -m coverage run --omit=*/tests/*,*/test_*.py -m pytest {context_path} && {python} -m coverage report --omit=*/tests/*,*/test_*.py"
     parser: "CoverageParser"
-    priority: 6
+    order: 6
     warning_threshold: 0.9
     error_threshold: 0.5
     run_in_target_env: true
@@ -265,43 +265,38 @@ tools:
       - coverage
       - pytest
 
-  complexity:
-    name: "radon cc"
+  radon-cc:
     command: "{python} -m radon cc --json {context_path}"
     parser: "ComplexityParser"
-    priority: 7
+    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"
-    priority: 8
+    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"
-    priority: 9
+    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"
     parser: "VultureParser"
-    priority: 10
+    order: 10
     warning_threshold: 0.9999
     error_threshold: 0.8
 
   interrogate:
-    name: "interrogate"
     command: "{python} -m interrogate {context_path} -v --fail-under 0"
     parser: "InterrogateParser"
-    priority: 11
+    order: 11
     warning_threshold: 0.8
     error_threshold: 0.3