codemri 0.1.0__tar.gz

codemri-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: codemri
+Version: 0.1.0
+Summary: Instant code quality reports for your Python projects — style, complexity, and an overall health score in one command
+Author-email: Suzzane Koranteng <korantengsuzzane@gmail.com>
+License-Expression: MIT
+Keywords: code quality,linting,complexity,cli,developer tools,static analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: ruff>=0.4.0
+Requires-Dist: radon>=6.0.0
+
+# CodeMRI
+
+**Instant code quality reports for your Python projects.**
+
+CodeMRI scans your codebase and gives you a single, easy-to-read health score — combining style violations and code complexity into one number, so you know exactly how healthy your code is and where to focus first.
+
+## Why CodeMRI?
+
+Most linters dump a wall of warnings and leave you to figure out what matters. CodeMRI instead gives you:
+
+- **One overall health score (0–100)** with a letter grade — like an MRI scan for your code
+- **A "Worst Offenders" leaderboard** — the exact functions and files causing the most pain, ranked by severity
+- **A clean, shareable HTML report** — perfect for pasting into a PR or sharing with your team
+- **Score history tracking** — see whether your codebase is improving or rotting over time, right from the CLI
+
+## Installation
+
+```bash
+pip install codemri
+```
+
+## Usage
+
+Scan the current directory:
+
+```bash
+codemri scan .
+```
+
+Scan a specific file or folder:
+
+```bash
+codemri scan path/to/project
+```
+
+Generate a shareable HTML report:
+
+```bash
+codemri scan . --html
+```
+
+View your score history over time:
+
+```bash
+codemri history .
+```
+
+Check the installed version:
+
+```bash
+codemri --version
+```
+
+## Example output
+
+────────────────── Overall Code Health ──────────────────╮
+│ 69/100   Grade: C                                        │
+╰────────────────────────────────────────────────────────╯
+Style score: 39/100  (9 issues across 59 lines)
+Complexity score: 98/100  (1 files analyzed)
+
+## How scoring works
+
+- **Style score** — based on the density of style/lint issues (via [ruff](https://github.com/astral-sh/ruff)) relative to lines of code
+- **Complexity score** — based on cyclomatic complexity rankings (via [radon](https://github.com/rubik/radon)) across all functions
+- **Overall score** — a 50/50 weighted average of the two, mapped to a letter grade (A–F)
+
+## License
+
+MIT

codemri-0.1.0/README.md

@@ -0,0 +1,70 @@
+# CodeMRI
+
+**Instant code quality reports for your Python projects.**
+
+CodeMRI scans your codebase and gives you a single, easy-to-read health score — combining style violations and code complexity into one number, so you know exactly how healthy your code is and where to focus first.
+
+## Why CodeMRI?
+
+Most linters dump a wall of warnings and leave you to figure out what matters. CodeMRI instead gives you:
+
+- **One overall health score (0–100)** with a letter grade — like an MRI scan for your code
+- **A "Worst Offenders" leaderboard** — the exact functions and files causing the most pain, ranked by severity
+- **A clean, shareable HTML report** — perfect for pasting into a PR or sharing with your team
+- **Score history tracking** — see whether your codebase is improving or rotting over time, right from the CLI
+
+## Installation
+
+```bash
+pip install codemri
+```
+
+## Usage
+
+Scan the current directory:
+
+```bash
+codemri scan .
+```
+
+Scan a specific file or folder:
+
+```bash
+codemri scan path/to/project
+```
+
+Generate a shareable HTML report:
+
+```bash
+codemri scan . --html
+```
+
+View your score history over time:
+
+```bash
+codemri history .
+```
+
+Check the installed version:
+
+```bash
+codemri --version
+```
+
+## Example output
+
+────────────────── Overall Code Health ──────────────────╮
+│ 69/100   Grade: C                                        │
+╰────────────────────────────────────────────────────────╯
+Style score: 39/100  (9 issues across 59 lines)
+Complexity score: 98/100  (1 files analyzed)
+
+## How scoring works
+
+- **Style score** — based on the density of style/lint issues (via [ruff](https://github.com/astral-sh/ruff)) relative to lines of code
+- **Complexity score** — based on cyclomatic complexity rankings (via [radon](https://github.com/rubik/radon)) across all functions
+- **Overall score** — a 50/50 weighted average of the two, mapped to a letter grade (A–F)
+
+## License
+
+MIT

codemri-0.1.0/codemri/cli.py

@@ -0,0 +1,365 @@
+import subprocess
+import json
+import os
+import sqlite3
+from datetime import datetime
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+app = typer.Typer(help="Instant code quality reports for your Python projects")
+console = Console()
+
+RADON_RANK_PENALTY = {
+    "A": 0,
+    "B": 5,
+    "C": 15,
+    "D": 30,
+    "E": 45,
+    "F": 60,
+}
+
+GRADE_COLORS = {
+    "A": "#22c55e",
+    "B": "#84cc16",
+    "C": "#eab308",
+    "D": "#f97316",
+    "F": "#ef4444",
+}
+
+
+def run_ruff(path: str):
+    result = subprocess.run(
+        ["ruff", "check", path, "--output-format=json"],
+        capture_output=True,
+        text=True,
+    )
+    if not result.stdout.strip():
+        return []
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return []
+
+
+def run_radon_complexity(path: str):
+    result = subprocess.run(
+        ["radon", "cc", path, "-j", "-e", "venv/*,*/venv/*,.venv/*,*/.venv/*"],
+        capture_output=True,
+        text=True,
+    )
+    if not result.stdout.strip():
+        return {}
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return {}
+
+
+def count_lines_of_code(path: str, complexity_data: dict) -> int:
+    total = 0
+    for file in complexity_data.keys():
+        try:
+            with open(file, "r", encoding="utf-8", errors="ignore") as f:
+                total += sum(1 for _ in f)
+        except (FileNotFoundError, OSError):
+            continue
+    return max(total, 1)
+
+
+def calculate_style_score(issues: list, loc: int) -> float:
+    issues_per_100_lines = (len(issues) / loc) * 100
+    score = 100 - (issues_per_100_lines * 4)
+    return max(0, min(100, score))
+
+
+def calculate_complexity_score(complexity_data: dict) -> float:
+    all_blocks = [block for blocks in complexity_data.values() for block in blocks]
+    if not all_blocks:
+        return 100.0
+    total_penalty = sum(RADON_RANK_PENALTY.get(b.get("rank", "A"), 0) for b in all_blocks)
+    avg_penalty = total_penalty / len(all_blocks)
+    score = 100 - avg_penalty
+    return max(0, min(100, score))
+
+
+def grade_and_color(score: float):
+    if score >= 90:
+        return "A", "bright_green"
+    elif score >= 75:
+        return "B", "green"
+    elif score >= 60:
+        return "C", "yellow"
+    elif score >= 40:
+        return "D", "orange3"
+    else:
+        return "F", "red"
+
+
+def build_worst_offenders(complexity_data: dict, issues: list, limit: int = 5):
+    issues_per_file = {}
+    for issue in issues:
+        fname = issue.get("filename", "")
+        issues_per_file[fname] = issues_per_file.get(fname, 0) + 1
+
+    offenders = []
+    for file, blocks in complexity_data.items():
+        file_issue_count = issues_per_file.get(file, 0)
+        for block in blocks:
+            rank = block.get("rank", "A")
+            penalty = RADON_RANK_PENALTY.get(rank, 0)
+            severity = penalty + (file_issue_count * 2)
+            if severity > 0:
+                offenders.append({
+                    "file": file,
+                    "function": block.get("name", "?"),
+                    "complexity": block.get("complexity", "?"),
+                    "rank": rank,
+                    "severity": severity,
+                })
+
+    offenders.sort(key=lambda x: x["severity"], reverse=True)
+    return offenders[:limit]
+
+
+def get_db_path(path: str) -> str:
+    base_dir = path if os.path.isdir(path) else os.path.dirname(path) or "."
+    return os.path.join(base_dir, ".codemri_history.db")
+
+
+def save_run_to_history(path: str, overall_score: int, style_score: float, complexity_score: float):
+    db_path = get_db_path(path)
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT NOT NULL,
+            overall_score INTEGER NOT NULL,
+            style_score REAL NOT NULL,
+            complexity_score REAL NOT NULL
+        )
+    """)
+    cursor.execute(
+        "INSERT INTO runs (timestamp, overall_score, style_score, complexity_score) VALUES (?, ?, ?, ?)",
+        (datetime.now().isoformat(timespec="seconds"), overall_score, style_score, complexity_score),
+    )
+    conn.commit()
+    conn.close()
+
+
+def load_history(path: str, limit: int = 10):
+    db_path = get_db_path(path)
+    if not os.path.exists(db_path):
+        return []
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    cursor.execute(
+        "SELECT timestamp, overall_score, style_score, complexity_score "
+        "FROM runs ORDER BY id DESC LIMIT ?",
+        (limit,),
+    )
+    rows = cursor.fetchall()
+    conn.close()
+    return list(reversed(rows))
+
+
+HTML_TEMPLATE = """<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<title>CodeMRI Code Quality Report</title>
+<style>
+  body { font-family: -apple-system, Segoe UI, sans-serif; background: #0f172a; color: #e2e8f0; padding: 40px; }
+  h1 { color: #f8fafc; }
+  .score-panel { background: #1e293b; border-left: 6px solid __COLOR__; padding: 24px; border-radius: 8px; margin: 20px 0; }
+  .score { font-size: 48px; font-weight: bold; color: __COLOR__; }
+  .grade { font-size: 24px; color: __COLOR__; }
+  .subscore { display: inline-block; margin-right: 40px; margin-top: 10px; }
+  table { width: 100%; border-collapse: collapse; margin-top: 16px; background: #1e293b; border-radius: 8px; overflow: hidden; }
+  th { background: #334155; text-align: left; padding: 10px; color: #94a3b8; }
+  td { padding: 10px; border-top: 1px solid #334155; font-size: 14px; }
+  .badge { padding: 2px 10px; border-radius: 4px; color: white; font-weight: bold; }
+  .section-title { margin-top: 40px; color: #f8fafc; }
+  .meta { color: #64748b; font-size: 13px; }
+</style>
+</head>
+<body>
+  <h1>CodeMRI Code Quality Report</h1>
+  <p class="meta">Path: __PATH__ | Generated: __TIMESTAMP__</p>
+
+  <div class="score-panel">
+    <div class="score">__SCORE__/100</div>
+    <div class="grade">Grade: __GRADE__</div>
+    <div class="subscore">Style: __STYLE_SCORE__/100</div>
+    <div class="subscore">Complexity: __COMPLEXITY_SCORE__/100</div>
+  </div>
+
+  <h2 class="section-title">Worst Offenders</h2>
+  <table>
+    <tr><th>File</th><th>Function</th><th>Complexity</th><th>Rank</th></tr>
+    __OFFENDERS_ROWS__
+  </table>
+
+  <h2 class="section-title">Style Issues</h2>
+  <table>
+    <tr><th>File</th><th>Line</th><th>Code</th><th>Message</th></tr>
+    __ISSUES_ROWS__
+  </table>
+</body>
+</html>"""
+
+
+def generate_html_report(path, overall_score, grade, style_score, complexity_score,
+                          issues, complexity_data, worst_offenders, output_file="codemri_report.html"):
+    color = GRADE_COLORS.get(grade, "#6b7280")
+
+    offenders_rows = ""
+    for o in worst_offenders:
+        rank_color = GRADE_COLORS.get(o["rank"], "#6b7280")
+        offenders_rows += (
+            "<tr><td>" + str(o["file"]) + "</td><td>" + str(o["function"]) + "</td><td>"
+            + str(o["complexity"]) + "</td><td><span class='badge' style='background:"
+            + rank_color + "'>" + str(o["rank"]) + "</span></td></tr>"
+        )
+    if not offenders_rows:
+        offenders_rows = "<tr><td colspan='4'>No major offenders found</td></tr>"
+
+    issues_rows = ""
+    for i in issues[:20]:
+        filename = i.get("filename", "?")
+        line = i.get("location", {}).get("row", "?")
+        code = i.get("code", "?")
+        message = i.get("message", "?")
+        issues_rows += (
+            "<tr><td>" + str(filename) + "</td><td>" + str(line) + "</td><td>"
+            + str(code) + "</td><td>" + str(message) + "</td></tr>"
+        )
+    if not issues_rows:
+        issues_rows = "<tr><td colspan='4'>No style issues found</td></tr>"
+
+    html = HTML_TEMPLATE
+    html = html.replace("__COLOR__", color)
+    html = html.replace("__PATH__", str(path))
+    html = html.replace("__TIMESTAMP__", datetime.now().strftime("%Y-%m-%d %H:%M"))
+    html = html.replace("__SCORE__", str(overall_score))
+    html = html.replace("__GRADE__", str(grade))
+    html = html.replace("__STYLE_SCORE__", str(round(style_score)))
+    html = html.replace("__COMPLEXITY_SCORE__", str(round(complexity_score)))
+    html = html.replace("__OFFENDERS_ROWS__", offenders_rows)
+    html = html.replace("__ISSUES_ROWS__", issues_rows)
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        f.write(html)
+    return output_file
+
+
+@app.command()
+def scan(
+    path: str = typer.Argument(".", help="Path to the file or directory to analyze"),
+    html: bool = typer.Option(False, "--html", help="Generate a shareable HTML report"),
+):
+    """Analyze code quality for the given path."""
+    console.print(f"[bold cyan]Scanning:[/bold cyan] {path}\n")
+
+    issues = run_ruff(path)
+    complexity_data = run_radon_complexity(path)
+    loc = count_lines_of_code(path, complexity_data)
+
+    style_score = calculate_style_score(issues, loc)
+    complexity_score = calculate_complexity_score(complexity_data)
+    overall_score = round((style_score * 0.5) + (complexity_score * 0.5))
+    grade, color = grade_and_color(overall_score)
+    save_run_to_history(path, overall_score, style_score, complexity_score)
+
+    console.print(
+        Panel(
+            f"[bold {color}]{overall_score}/100[/bold {color}]   Grade: [bold {color}]{grade}[/bold {color}]",
+            title="Overall Code Health",
+            border_style=color,
+        )
+    )
+
+    console.print(f"\n[bold]Style score:[/bold] {round(style_score)}/100  "
+                  f"({len(issues)} issues across {loc} lines)")
+    console.print(f"[bold]Complexity score:[/bold] {round(complexity_score)}/100  "
+                  f"({len(complexity_data)} files analyzed)\n")
+
+    worst_offenders = build_worst_offenders(complexity_data, issues)
+    if worst_offenders:
+        offenders_table = Table(show_header=True, header_style="bold red", title="Worst Offenders")
+        offenders_table.add_column("File")
+        offenders_table.add_column("Function")
+        offenders_table.add_column("Complexity")
+        offenders_table.add_column("Rank")
+        for o in worst_offenders:
+            offenders_table.add_row(o["file"], o["function"], str(o["complexity"]), o["rank"])
+        console.print(offenders_table)
+        console.print()
+
+    if issues:
+        table = Table(show_header=True, header_style="bold magenta", title="Style Issues")
+        table.add_column("File")
+        table.add_column("Line")
+        table.add_column("Code")
+        table.add_column("Message")
+        for issue in issues[:10]:
+            table.add_row(
+                issue.get("filename", "?"),
+                str(issue.get("location", {}).get("row", "?")),
+                issue.get("code", "?"),
+                issue.get("message", "?"),
+            )
+        console.print(table)
+
+    if html:
+        output_file = generate_html_report(
+            path, overall_score, grade, style_score, complexity_score,
+            issues, complexity_data, worst_offenders
+        )
+        full_path = os.path.abspath(output_file)
+        console.print(f"\n[bold green]HTML report generated:[/bold green] {full_path}")
+
+
+@app.command()
+def history(path: str = typer.Argument(".", help="Path whose scan history to show")):
+    """Show score trend across previous scans."""
+    rows = load_history(path)
+
+    if not rows:
+        console.print("[yellow]No scan history found yet. Run 'lintra' a few times first.[/yellow]")
+        return
+
+    table = Table(show_header=True, header_style="bold cyan", title="Score History")
+    table.add_column("Timestamp")
+    table.add_column("Overall")
+    table.add_column("Style")
+    table.add_column("Complexity")
+    table.add_column("Trend")
+
+    prev_score = None
+    for timestamp, overall_score, style_score, complexity_score in rows:
+        if prev_score is None:
+            trend = "—"
+        elif overall_score > prev_score:
+            trend = "[green]▲ improving[/green]"
+        elif overall_score < prev_score:
+            trend = "[red]▼ declining[/red]"
+        else:
+            trend = "[dim]● stable[/dim]"
+        prev_score = overall_score
+
+        table.add_row(
+            timestamp,
+            f"{overall_score}/100",
+            f"{round(style_score)}/100",
+            f"{round(complexity_score)}/100",
+            trend,
+        )
+
+    console.print(table)
+
+
+if __name__ == "__main__":
+    app()

codemri-0.1.0/codemri.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: codemri
+Version: 0.1.0
+Summary: Instant code quality reports for your Python projects — style, complexity, and an overall health score in one command
+Author-email: Suzzane Koranteng <korantengsuzzane@gmail.com>
+License-Expression: MIT
+Keywords: code quality,linting,complexity,cli,developer tools,static analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: ruff>=0.4.0
+Requires-Dist: radon>=6.0.0
+
+# CodeMRI
+
+**Instant code quality reports for your Python projects.**
+
+CodeMRI scans your codebase and gives you a single, easy-to-read health score — combining style violations and code complexity into one number, so you know exactly how healthy your code is and where to focus first.
+
+## Why CodeMRI?
+
+Most linters dump a wall of warnings and leave you to figure out what matters. CodeMRI instead gives you:
+
+- **One overall health score (0–100)** with a letter grade — like an MRI scan for your code
+- **A "Worst Offenders" leaderboard** — the exact functions and files causing the most pain, ranked by severity
+- **A clean, shareable HTML report** — perfect for pasting into a PR or sharing with your team
+- **Score history tracking** — see whether your codebase is improving or rotting over time, right from the CLI
+
+## Installation
+
+```bash
+pip install codemri
+```
+
+## Usage
+
+Scan the current directory:
+
+```bash
+codemri scan .
+```
+
+Scan a specific file or folder:
+
+```bash
+codemri scan path/to/project
+```
+
+Generate a shareable HTML report:
+
+```bash
+codemri scan . --html
+```
+
+View your score history over time:
+
+```bash
+codemri history .
+```
+
+Check the installed version:
+
+```bash
+codemri --version
+```
+
+## Example output
+
+────────────────── Overall Code Health ──────────────────╮
+│ 69/100   Grade: C                                        │
+╰────────────────────────────────────────────────────────╯
+Style score: 39/100  (9 issues across 59 lines)
+Complexity score: 98/100  (1 files analyzed)
+
+## How scoring works
+
+- **Style score** — based on the density of style/lint issues (via [ruff](https://github.com/astral-sh/ruff)) relative to lines of code
+- **Complexity score** — based on cyclomatic complexity rankings (via [radon](https://github.com/rubik/radon)) across all functions
+- **Overall score** — a 50/50 weighted average of the two, mapped to a letter grade (A–F)
+
+## License
+
+MIT

codemri-0.1.0/codemri.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+codemri/__init__.py
+codemri/cli.py
+codemri.egg-info/PKG-INFO
+codemri.egg-info/SOURCES.txt
+codemri.egg-info/dependency_links.txt
+codemri.egg-info/entry_points.txt
+codemri.egg-info/requires.txt
+codemri.egg-info/top_level.txt

codemri-0.1.0/codemri.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

codemri-0.1.0/codemri.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codemri = codemri.cli:app

codemri-0.1.0/codemri.egg-info/requires.txt

@@ -0,0 +1,4 @@
+typer>=0.9.0
+rich>=13.0.0
+ruff>=0.4.0
+radon>=6.0.0

codemri-0.1.0/codemri.egg-info/top_level.txt

@@ -0,0 +1 @@
+codemri

codemri-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "codemri"
+version = "0.1.0"
+description = "Instant code quality reports for your Python projects — style, complexity, and an overall health score in one command"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    { name = "Suzzane Koranteng", email = "korantengsuzzane@gmail.com" }
+]
+keywords = ["code quality", "linting", "complexity", "cli", "developer tools", "static analysis"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "ruff>=0.4.0",
+    "radon>=6.0.0",
+]
+
+[project.scripts]
+codemri = "codemri.cli:app"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["codemri"]

codemri-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+