python-code-quality 0.1.4__tar.gz

python_code_quality-0.1.4/.github/workflows/python-publish.yml

@@ -0,0 +1,70 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Build release distributions
+        run: |
+          uv build
+    
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
+    environment:
+      name: pypi
+      # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status:
+      # url: https://pypi.org/p/YOURPROJECT
+      #
+      # ALTERNATIVE: if your GitHub Release name is the PyPI project version string
+      # ALTERNATIVE: exactly, uncomment the following line instead:
+      url: https://pypi.org/project/python-code-quality/${{ github.event.release.name }}
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

python_code_quality-0.1.4/.gitignore

@@ -0,0 +1,17 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.*_cache/
+# Virtual environments
+.venv
+profile.prof
+analysis_results.json
+.coverage
+.aider*
+.claude
+.cq.json
+

python_code_quality-0.1.4/.python-version

@@ -0,0 +1 @@
+3.14

python_code_quality-0.1.4/CLAUDE.md

@@ -0,0 +1,54 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+CQ is a Python CLI tool for iterative, LLM-assisted code improvement. The primary use case is:
+
+```bash
+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 →
+tests → coverage → complexity → dead code → style) and aggregates results into
+a single score.
+
+## Commands
+
+```bash
+# Run tests
+uv run pytest
+
+# Run a single test
+uv run pytest tests/test_common.py::test_score_logistic_variant
+
+# Run the CLI
+uv run cq check              # table output, current directory
+uv run cq check -o llm       # LLM markdown, primary use case
+uv run cq check -o score     # numeric score
+uv run cq check path/to/project/
+
+# Lint
+uv run ruff check src/
+```
+
+## Architecture
+
+**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.
+- **`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.
+
+## Adding a New Analysis Tool
+
+1. Add tool entry in `config/tools.yaml` with command template, parser name, priority, 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.4/LICENSE

@@ -0,0 +1,21 @@
+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.

python_code_quality-0.1.4/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: python-code-quality
+Version: 0.1.4
+Summary: Python Code Quality Analysis Tool - feed the results from 11 CQ CQ straight into an LLM.
+Project-URL: Homepage, https://github.com/rhiza-fr/py-cq
+Project-URL: Repository, https://github.com/rhiza-fr/py-cq
+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-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
+Requires-Dist: ruff>=0.14.1
+Requires-Dist: ty>=0.0.17
+Requires-Dist: typer>=0.16.0
+Requires-Dist: vulture>=2.14
+Description-Content-Type: text/markdown
+
+# CQ - Python Code Quality Analysis Tool
+
+Python Code Quality Analysis Tool - feed the results from 11 CQ tools straight into an LLM. The primary workflow is:
+
+```bash
+cq check -o llm   # get the single most critical defect as markdown
+```
+
+Feed that output to an LLM, apply the fix, repeat until the score is clean.
+
+## Install
+
+```bash
+uv tool install python-code-quality
+
+# or
+git pull https://github.com/rhiza-fr/py-cq.git
+cd py-cq
+uv tool install .
+```
+
+## Tools
+
+CQ runs these tools in *parallel*:
+
+| Priority | Tool | Measures |
+|----------|------|----------|
+| 1 | compileall | Syntax errors |
+| 2 | bandit | Security vulnerabilities |
+| 3 | ruff | Lint / style |
+| 4 | ty | Type errors |
+| 5 | pytest | Test pass rate |
+| 6 | coverage | Test coverage |
+| 7 | radon cc | Cyclomatic complexity |
+| 8 | radon mi | Maintainability index |
+| 9 | radon hal | Halstead volume / bug estimate |
+| 10 | vulture | Dead code |
+| 11 | interrogate | Docstring coverage |
+
+## Usage
+
+```bash
+# LLM workflow: get the top defect as markdown (primary use case)
+cq check -o llm
+
+# Rich table with all metrics (default, also saves .cq.json)
+cq check
+
+# Numeric score only — useful in CI or scripts
+cq check -o score
+
+# Full JSON output
+cq check -o json
+
+# Explicit path (defaults to current directory)
+cq check path/to/project/
+cq check path/to/file.py
+
+# Run sequentially (1 worker) instead of in parallel
+cq check --workers 1
+
+# Clear cached results before running
+cq check --clear-cache
+
+# Save table output to a custom file
+cq check --out-file custom_results.json
+
+# Show effective tool configuration (thresholds, enabled/disabled status)
+cq config
+cq config path/to/project/
+```
+
+## Output
+
+```bash
+> cq check .
+```
+
+```python
+┏━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━┓
+┃ 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       │
+│ pytest           │    0.91s │                     tests │ 1.000   │ OK       │
+│ coverage         │    1.26s │                  coverage │ 0.910   │ OK       │
+│ radon cc         │    0.32s │                simplicity │ 0.982   │ OK       │
+│ radon mi         │    0.38s │           maintainability │ 0.869   │ OK       │
+│ radon hal        │    0.30s │             file_bug_free │ 0.928   │ OK       │
+│ radon hal        │          │            file_smallness │ 0.851   │ OK       │
+│ radon hal        │          │        functions_bug_free │ 0.913   │ OK       │
+│ radon hal        │          │       functions_smallness │ 0.724   │ OK       │
+│ vulture          │    0.32s │                 dead_code │ 1.000   │ OK       │
+│ interrogate      │    0.36s │              doc_coverage │ 1.000   │ OK       │
+│                  │          │                     Score │ 0.965   │          │
+└──────────────────┴──────────┴───────────────────────────┴─────────┴──────────┘
+```
+```bash
+> cq check . -o score
+```
+```python
+0.9662730667181059 # this is designed to approach but not reach 1.0
+```
+
+```bash
+> cq check . -o llm
+```
+
+```md
+`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.
+```
+
+## Configuration
+
+Add a `[tool.cq]` section to your project's `pyproject.toml`:
+
+```toml
+[tool.cq]
+# Skip tools that are slow or not relevant to your project
+disable = ["coverage", "interrogate"]
+
+# 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`.
+
+## LLM workflow
+
+`-o llm` selects the single worst-scoring tool and formats its top defect as
+concise markdown. The LLM fixes it, you re-run `cq check -o llm`, and repeat
+until all tools are green. Priority order ensures the most critical category
+(security, type errors, failing tests) is fixed before cosmetic ones.
+
+## Tools
+
+Many thanks to all the wonderful maintainers of :
+
+- [compileall](https://docs.python.org/3/library/compileall.html)
+- [bandit](https://github.com/PyCQA/bandit)
+- [ruff](https://github.com/astral-sh/ruff)
+- [ty](https://github.com/astral-sh/ty)
+- [pytest](https://github.com/pytest-dev/pytest)
+- [coverage.py](https://github.com/nedbat/coveragepy)
+- [radon](https://github.com/rubik/radon)
+- [vulture](https://github.com/jendrikseipp/vulture)
+- [interrogate](https://github.com/econchick/interrogate)

python_code_quality-0.1.4/README.md

@@ -0,0 +1,162 @@
+# CQ - Python Code Quality Analysis Tool
+
+Python Code Quality Analysis Tool - feed the results from 11 CQ tools straight into an LLM. The primary workflow is:
+
+```bash
+cq check -o llm   # get the single most critical defect as markdown
+```
+
+Feed that output to an LLM, apply the fix, repeat until the score is clean.
+
+## Install
+
+```bash
+uv tool install python-code-quality
+
+# or
+git pull https://github.com/rhiza-fr/py-cq.git
+cd py-cq
+uv tool install .
+```
+
+## Tools
+
+CQ runs these tools in *parallel*:
+
+| Priority | Tool | Measures |
+|----------|------|----------|
+| 1 | compileall | Syntax errors |
+| 2 | bandit | Security vulnerabilities |
+| 3 | ruff | Lint / style |
+| 4 | ty | Type errors |
+| 5 | pytest | Test pass rate |
+| 6 | coverage | Test coverage |
+| 7 | radon cc | Cyclomatic complexity |
+| 8 | radon mi | Maintainability index |
+| 9 | radon hal | Halstead volume / bug estimate |
+| 10 | vulture | Dead code |
+| 11 | interrogate | Docstring coverage |
+
+## Usage
+
+```bash
+# LLM workflow: get the top defect as markdown (primary use case)
+cq check -o llm
+
+# Rich table with all metrics (default, also saves .cq.json)
+cq check
+
+# Numeric score only — useful in CI or scripts
+cq check -o score
+
+# Full JSON output
+cq check -o json
+
+# Explicit path (defaults to current directory)
+cq check path/to/project/
+cq check path/to/file.py
+
+# Run sequentially (1 worker) instead of in parallel
+cq check --workers 1
+
+# Clear cached results before running
+cq check --clear-cache
+
+# Save table output to a custom file
+cq check --out-file custom_results.json
+
+# Show effective tool configuration (thresholds, enabled/disabled status)
+cq config
+cq config path/to/project/
+```
+
+## Output
+
+```bash
+> cq check .
+```
+
+```python
+┏━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━┓
+┃ 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       │
+│ pytest           │    0.91s │                     tests │ 1.000   │ OK       │
+│ coverage         │    1.26s │                  coverage │ 0.910   │ OK       │
+│ radon cc         │    0.32s │                simplicity │ 0.982   │ OK       │
+│ radon mi         │    0.38s │           maintainability │ 0.869   │ OK       │
+│ radon hal        │    0.30s │             file_bug_free │ 0.928   │ OK       │
+│ radon hal        │          │            file_smallness │ 0.851   │ OK       │
+│ radon hal        │          │        functions_bug_free │ 0.913   │ OK       │
+│ radon hal        │          │       functions_smallness │ 0.724   │ OK       │
+│ vulture          │    0.32s │                 dead_code │ 1.000   │ OK       │
+│ interrogate      │    0.36s │              doc_coverage │ 1.000   │ OK       │
+│                  │          │                     Score │ 0.965   │          │
+└──────────────────┴──────────┴───────────────────────────┴─────────┴──────────┘
+```
+```bash
+> cq check . -o score
+```
+```python
+0.9662730667181059 # this is designed to approach but not reach 1.0
+```
+
+```bash
+> cq check . -o llm
+```
+
+```md
+`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.
+```
+
+## Configuration
+
+Add a `[tool.cq]` section to your project's `pyproject.toml`:
+
+```toml
+[tool.cq]
+# Skip tools that are slow or not relevant to your project
+disable = ["coverage", "interrogate"]
+
+# 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`.
+
+## LLM workflow
+
+`-o llm` selects the single worst-scoring tool and formats its top defect as
+concise markdown. The LLM fixes it, you re-run `cq check -o llm`, and repeat
+until all tools are green. Priority order ensures the most critical category
+(security, type errors, failing tests) is fixed before cosmetic ones.
+
+## Tools
+
+Many thanks to all the wonderful maintainers of :
+
+- [compileall](https://docs.python.org/3/library/compileall.html)
+- [bandit](https://github.com/PyCQA/bandit)
+- [ruff](https://github.com/astral-sh/ruff)
+- [ty](https://github.com/astral-sh/ty)
+- [pytest](https://github.com/pytest-dev/pytest)
+- [coverage.py](https://github.com/nedbat/coveragepy)
+- [radon](https://github.com/rubik/radon)
+- [vulture](https://github.com/jendrikseipp/vulture)
+- [interrogate](https://github.com/econchick/interrogate)

python_code_quality-0.1.4/data/problems/travelling_salesman/ts_bad.py

@@ -0,0 +1,65 @@
+"""Intentionally bad implementation of the Travelling Salesman Problem for testing purposes."""
+import math
+import time
+
+# Bad Variable Naming
+# cities = [(0, 0), (1, 5), (5, 3), (3, 1), (1, 4)]
+
+
+# Bad Method Naming
+def calc_dist(city1, city2):
+    """Calculates the distance between two cities."""
+    return math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
+
+
+# Missing Docstrings
+def find_nearest_city(cities, current_city):
+    """Finds the nearest city to the current city."""
+    min_dist = float("inf")
+    nearest_city = None
+    for city in cities:
+        # unused = 'bug'
+        dist = calc_dist(current_city, city)
+        if dist < min_dist:
+            min_dist = dist
+            nearest_city = city
+    return nearest_city
+
+
+# Inefficient Loop
+def generate_tour(cities, start_city):
+    """Generates a tour starting from start_city visiting all cities."""
+    #error = {a = b}
+    tour = [start_city]
+    total_distance = 0
+    unvisited = set(cities)
+    unvisited.remove(start_city)
+
+    time.sleep(0.1)  # Simulating a delay for no reason
+    while unvisited:
+        nearest = find_nearest_city(cities, tour[-1])
+        tour.append(nearest)
+        total_distance += calc_dist(tour[-2], tour[-1])
+        unvisited.remove(nearest)
+
+    tour.append(tour[0])  # Return to start
+    total_distance += calc_dist(tour[-1], tour[0])
+    return tour, total_distance
+
+
+# Poor Memory Use (Not a major issue here, but illustrates the point)
+# Could be improved by using generators or iterators if dealing with very large datasets.
+
+
+def main():
+    """Runs the bad TSP implementation on a sample set of cities."""
+    cities = [(0, 0), (1, 5), (5, 3), (3, 1), (1, 4)]
+
+    tour, total_distance = generate_tour(cities, cities[0])
+
+    print("Tour:", tour)
+    print("Total Distance:", total_distance)
+
+
+if __name__ == "__main__":
+    main()

python_code_quality-0.1.4/data/problems/travelling_salesman/ts_good.py

@@ -0,0 +1,61 @@
+"""Good implementation of the Travelling Salesman Problem using nearest-neighbor heuristic."""
+import math
+import random
+
+
+def distance(city1, city2):
+    """Calculates the Euclidean distance between two cities."""
+    return math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
+
+
+def test_calc_dist():
+    """Tests the calc_dist function."""
+    assert distance((0, 0), (3, 4)) == 5.0, "Test failed!"
+    assert distance((1, 1), (4, 5)) == 5.0, "Test failed!"
+    # assert False
+    print("All tests passed!")
+
+
+def nearest_neighbor(cities):
+    """Implements the Nearest Neighbor heuristic for the TSP."""
+    current_city = random.choice(cities)  # Start at a random city
+    unvisited_cities = set(cities)
+    unvisited_cities.remove(current_city)
+    tour = [current_city]
+    total_distance = 0
+
+    while unvisited_cities:
+        nearest_city = None
+        min_dist = float("inf")
+
+        for city in unvisited_cities:
+            dist = distance(current_city, city)
+            if dist < min_dist:
+                min_dist = dist
+                nearest_city = city
+
+        tour.append(nearest_city)
+        total_distance += min_dist
+        current_city = nearest_city
+        unvisited_cities.remove(current_city)
+
+    # Return to the starting city
+    total_distance += distance(current_city, cities[0])
+    tour.append(cities[0])
+
+    return tour, total_distance
+
+
+def main():
+    """Runs the nearest-neighbor TSP on a sample set of cities."""
+    # Example cities (you can change these)
+    cities = [(0, 0), (1, 5), (5, 3), (3, 1), (1, 4), (6, 12), (4, 1), (9, 13), (12, 4), (6, 14)]
+
+    tour, total_distance = nearest_neighbor(cities)
+
+    print("Tour:", tour)
+    print("Total Distance:", total_distance)
+
+
+if __name__ == "__main__":
+    main()

python_code_quality-0.1.4/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "python-code-quality"
+version = "0.1.4"
+description = "Python Code Quality Analysis Tool - feed the results from 11 CQ CQ straight into an LLM."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [{name = "Chris Kilner", email = "chris@rhiza.fr"}]
+
+dependencies = [
+    "bandit>=1.8.0",
+    "coverage>=7.8.2",
+    "diskcache>=5.6.3",
+    "interrogate>=1.7.0",
+    "pytest>=8.4.0",
+    "pytest-cov>=6.1.1",
+    "pytest-json-report>=1.5.0",
+    "pyyaml>=6.0.2",
+    "radon>=6.0.1",
+    "rich>=14.0.0",
+    "ruff>=0.14.1",
+    "ty>=0.0.17",
+    "typer>=0.16.0",
+    "vulture>=2.14",
+]
+
+[project.urls]
+Homepage = "https://github.com/rhiza-fr/py-cq"
+Repository = "https://github.com/rhiza-fr/py-cq"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/py_cq"]
+
+[project.scripts]
+cq = "py_cq.main:main"