codebase-stats 0.0.1__tar.gz → 0.0.2__tar.gz

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebase-stats
-Version: 0.0.1
+Version: 0.0.2
 Summary: Comprehensive codebase analysis library with coverage, metrics, and test duration analysis
 Author-email: Your Name <your.email@example.com>
 License: MIT

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/__init__.py

@@ -45,12 +45,16 @@ from .coverage import (
     show_pragma_histogram,
 )
 
-# Code quality metrics
-from .metrics import (
+# Radon analysis
+from .radon import (
     run_radon,
     run_radon_mi,
     run_radon_raw,
     run_radon_hal,
+)
+
+# Code quality metrics
+from .metrics import (
     show_complexity_histogram,
     show_mi_histogram,
     show_raw_histogram,

codebase_stats-0.0.2/codebase_stats/cli.py

@@ -0,0 +1,381 @@
+#!/usr/bin/env python3
+"""
+coverage_report.py — Coverage inspector + test report analyser.
+
+Features:
+  1. Coverage distribution histogram          (needs coverage.json)
+  2. Low-coverage file listing                (needs coverage.json)
+  3. Test duration histogram                  (needs --report report.json)
+  4. File size distribution histogram         (scanned from disk)
+
+Generate the inputs with:
+  pip install pytest-json-report
+  pytest ... --cov=app --cov-report=json \
+             --json-report --json-report-file=report.json
+
+--show options (combinable, default: all available):
+  coverage    coverage distribution histogram + blame
+  duration    test duration histogram + blame      (requires --report)
+  sizes       file size histogram + blame          (requires --fs-root)
+  list        low-coverage file table
+  histograms  shorthand for all histograms: coverage duration sizes complexity mi raw hal  (no blame, no table)
+  complexity  cyclomatic complexity histogram + high-CC/low-coverage blame  (requires --radon-root)
+  mi          maintainability index histogram + low-MI blame               (requires --radon-root)
+  raw         comment ratio histogram + under-documented blame             (requires --radon-root)
+  hal         halstead metrics histogram + high-bug-estimate blame         (requires --radon-root)
+  tree        file tree analyzer (counts files and subfolders)             (requires --tree-root)
+  blame       quality blame sections only (combine with histograms or coverage/duration/sizes)
+  all         everything
+
+Usage:
+  python cli.py coverage.json
+  python cli.py coverage.json --report report.json
+  python cli.py coverage.json --show histograms --report report.json --fs-root app
+  python cli.py coverage.json --show coverage
+  python cli.py coverage.json --report report.json --show duration
+  python cli.py coverage.json --show list --threshold 80
+  python cli.py coverage.json --report report.json --show coverage duration
+"""
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from codebase_stats import (
+    analyze_tree,
+    load_coverage,
+    load_report,
+    parse_sorts,
+    precompute_coverage_stats,
+    run_radon,
+    run_radon_hal,
+    run_radon_mi,
+    run_radon_raw,
+    scan_pragma_counts,
+    show_complexity_histogram,
+    show_coverage_histogram,
+    show_duration_histogram,
+    show_file_size_distribution,
+    show_hal_histogram,
+    show_low_coverage,
+    show_mi_histogram,
+    show_raw_histogram,
+)
+
+VALID_VIEWS = {
+    "coverage",
+    "duration",
+    "sizes",
+    "list",
+    "histograms",
+    "complexity",
+    "mi",
+    "raw",
+    "hal",
+    "tree",
+    "blame",
+    "all",
+}
+
+
+def main():
+    p = argparse.ArgumentParser(
+        description="Coverage inspector + test report analyser",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    p.add_argument(
+        "coverage_file",
+        nargs="?",
+        default="coverage.json",
+        help="Path to coverage.json (default: coverage.json)",
+    )
+
+    # Duration
+    p.add_argument(
+        "--report",
+        metavar="FILE",
+        default=None,
+        help="pytest-json-report file for the duration histogram",
+    )
+    p.add_argument(
+        "--slow-threshold",
+        type=float,
+        default=1.0,
+        metavar="SECS",
+        help="Slow-test threshold in seconds (default: 1.0)",
+    )
+
+    # File sizes
+    p.add_argument(
+        "--fs-root",
+        default=".",
+        metavar="DIR",
+        help="Root directory to scan for file-size histogram (default: .)",
+    )
+    p.add_argument(
+        "--ext", default="py", metavar="EXT", help="File extension to measure (default: py)"
+    )
+    p.add_argument(
+        "--fs-percentiles",
+        default="25,50,75,90,95,99",
+        metavar="LIST",
+        help="Comma-separated percentiles for file-size histogram",
+    )
+    p.add_argument(
+        "--fs-above",
+        type=int,
+        default=None,
+        metavar="PCT",
+        help="List files above this percentile (e.g. 95)",
+    )
+
+    # File tree
+    p.add_argument(
+        "--tree-root",
+        default=None,
+        metavar="DIR",
+        help="Root directory for file tree analysis (e.g. app)",
+    )
+
+    # Radon analysis root (used by --show complexity / mi / raw / hal)
+    p.add_argument(
+        "--radon-root",
+        default=None,
+        metavar="DIR",
+        help="Root directory for all radon analyses (e.g. app)",
+    )
+    p.add_argument(
+        "--debug-radon",
+        action="store_true",
+        help="Print first 2 raw entries from each radon command for path diagnostics",
+    )
+
+    # Low-coverage listing
+    p.add_argument(
+        "--threshold", type=float, default=90.0, help="Show files below this %% (default: 50)"
+    )
+    p.add_argument(
+        "--max",
+        dest="max_threshold",
+        type=float,
+        default=None,
+        help="Upper bound %% (range filter)",
+    )
+    p.add_argument(
+        "--top",
+        dest="top_n",
+        type=int,
+        default=20,
+        help="Max rows in file listing (0 = all, default: 20)",
+    )
+    p.add_argument(
+        "--sort",
+        dest="sort_specs",
+        nargs="+",
+        default=["priority:desc"],
+        metavar="FIELD[:asc|desc]",
+        help="Sort fields: priority coverage layer missing missing_pct",
+    )
+    p.add_argument("--sort-order", choices=["asc", "desc"], default="desc")
+    p.add_argument(
+        "--show-lines", action="store_true", help="Print missing line numbers under each file"
+    )
+
+    # Shared
+    p.add_argument("--bins", type=int, default=10, help="Histogram bin count (default: 10)")
+    p.add_argument(
+        "--blame-limit",
+        type=int,
+        default=20,
+        metavar="N",
+        help="Max entries in quality blame sections (default: 20, 0 = all)",
+    )
+
+    # View selector
+    p.add_argument(
+        "--show",
+        nargs="+",
+        metavar="VIEW",
+        default=["all"],
+        help=(
+            "Sections to display. Options: "
+            "coverage  duration  sizes  list  histograms  blame  all. "
+            "Default: all.  histograms = bars only (no blame, no table). complexity = CC histogram. "
+            "Add blame to include quality blame sections."
+        ),
+    )
+
+    args = p.parse_args()
+
+    # Validate views
+    unknown = set(args.show) - VALID_VIEWS
+    if unknown:
+        p.error(
+            f"Unknown --show value(s): {', '.join(sorted(unknown))}. "
+            f"Valid: {', '.join(sorted(VALID_VIEWS))}"
+        )
+
+    views = set(args.show)
+    show_all = "all" in views
+    show_hists = "histograms" in views  # shorthand: coverage+duration+sizes (no blame, no list)
+    want_cov = show_all or show_hists or "coverage" in views
+    want_dur = show_all or show_hists or "duration" in views
+    want_size = show_all or show_hists or "sizes" in views
+    want_blame = show_all or "blame" in views  # histograms alone → no blame
+    want_complexity = show_all or show_hists or "complexity" in views
+    want_mi = show_all or show_hists or "mi" in views
+    want_raw = show_all or show_hists or "raw" in views
+    want_hal = show_all or show_hists or "hal" in views
+    want_tree = show_all or "tree" in views
+    want_list = show_all or "list" in views
+
+    if want_dur and not args.report:
+        if "duration" in views or show_hists:
+            p.error("--show duration/histograms requires --report <report.json>")
+        want_dur = False  # silently skip when --show all and no report provided
+
+    pcts = [int(x.strip()) for x in args.fs_percentiles.split(",") if x.strip()]
+    top_n = args.top_n if args.top_n > 0 else None
+    sorts = parse_sorts(args.sort_specs, args.sort_order)
+
+    # Optionally run radon analyses
+    radon_root = args.radon_root
+    any_radon = want_complexity or want_mi or want_raw or want_hal
+    if any_radon and not radon_root:
+        needs = [
+            v
+            for v, w in [
+                ("complexity", want_complexity),
+                ("mi", want_mi),
+                ("raw", want_raw),
+                ("hal", want_hal),
+            ]
+            if w
+        ]
+        print(f"⚠️  --show {'/'.join(needs)} requires --radon-root <dir>   (skipping)")
+        want_complexity = want_mi = want_raw = want_hal = False
+
+    _dbg = args.debug_radon
+
+    # Run all requested radon subcommands in parallel
+    if radon_root:
+        tasks = {}
+        wanted = {
+            "cc": want_complexity,
+            "mi": want_mi,
+            "raw": want_raw,
+            "hal": want_hal,
+        }
+        runners = {
+            "cc": lambda: run_radon(radon_root, debug=_dbg),
+            "mi": lambda: run_radon_mi(radon_root, debug=_dbg),
+            "raw": lambda: run_radon_raw(radon_root, debug=_dbg),
+            "hal": lambda: run_radon_hal(radon_root, debug=_dbg),
+        }
+        # Always run all four when radon-root is given so the summary has full
+        # data — but only the explicitly-requested ones block the display.
+        with ThreadPoolExecutor(max_workers=4) as pool:
+            futures = {pool.submit(fn): key for key, fn in runners.items()}
+            results = {key: {} for key in runners}
+            for future in as_completed(futures):
+                key = futures[future]
+                try:
+                    results[key] = future.result()
+                except Exception as e:
+                    print(f"⚠️  radon {key} failed: {e}")
+        complexity_map, mi_map, raw_map, hal_map = (
+            results["cc"],
+            results["mi"],
+            results["raw"],
+            results["hal"],
+        )
+        if _dbg:
+            for name, m in [
+                ("cc", complexity_map),
+                ("mi", mi_map),
+                ("raw", raw_map),
+                ("hal", hal_map),
+            ]:
+                print(f"  [debug] {name}: {len(m)} entries  sample key: {next(iter(m), 'n/a')!r}")
+    else:
+        complexity_map = mi_map = raw_map = hal_map = {}
+
+    # Pragma: no cover scan (use radon_root if available, else fs_root)
+    pragma_root = radon_root if radon_root else (args.fs_root if args.fs_root != "." else None)
+    pragma_counts: dict[str, int] = {}
+    if want_cov and pragma_root:
+        pragma_counts = scan_pragma_counts(pragma_root)
+
+    # Single precompute pass over coverage.json
+    cov_data = load_coverage(args.coverage_file)
+    stats = precompute_coverage_stats(cov_data, complexity_map, mi_map, raw_map, hal_map)
+
+    if want_cov:
+        show_coverage_histogram(
+            stats,
+            bins=args.bins,
+            blame_limit=args.blame_limit,
+            show_blame=want_blame,
+            threshold=args.threshold,
+            pragma_counts=pragma_counts,
+        )
+
+    if want_dur:
+        show_duration_histogram(
+            load_report(args.report),
+            bins=args.bins,
+            slow_threshold=args.slow_threshold,
+            blame_limit=args.blame_limit,
+            show_blame=want_blame,
+        )
+
+    if want_size:
+        show_file_size_distribution(
+            root=args.fs_root,
+            extension=args.ext,
+            percentiles=pcts,
+            show_above_pct=args.fs_above,
+            bins=args.bins,
+            blame_limit=args.blame_limit,
+            show_blame=want_blame,
+        )
+
+    if want_list:
+        show_low_coverage(
+            stats,
+            threshold=args.threshold,
+            max_threshold=args.max_threshold,
+            top_n=top_n,
+            sorts=sorts,
+            show_lines=args.show_lines,
+        )
+
+    if want_complexity:
+        show_complexity_histogram(
+            stats, bins=args.bins, blame_limit=args.blame_limit, show_blame=want_blame
+        )
+
+    if want_mi:
+        show_mi_histogram(
+            stats, bins=args.bins, blame_limit=args.blame_limit, show_blame=want_blame
+        )
+
+    if want_raw:
+        show_raw_histogram(
+            stats, bins=args.bins, blame_limit=args.blame_limit, show_blame=want_blame
+        )
+
+    if want_hal:
+        show_hal_histogram(
+            stats, bins=args.bins, blame_limit=args.blame_limit, show_blame=want_blame
+        )
+
+    if want_tree:
+        if args.tree_root:
+            analyze_tree(args.tree_root, bins=args.bins, blame_limit=args.blame_limit)
+        else:
+            print("⚠️  --show tree requires --tree-root <dir>")
+
+
+if __name__ == "__main__":
+    main()

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/core.py

@@ -7,13 +7,13 @@ from pathlib import Path
 
 def load_coverage(path: str) -> dict:
     """Load and parse a coverage.json file.
-    
+
     Args:
         path: Path to coverage.json file
-        
+
     Returns:
         Parsed coverage data dictionary
-        
+
     Raises:
         SystemExit: On file not found or invalid JSON
     """
@@ -31,13 +31,13 @@ def load_coverage(path: str) -> dict:
 
 def load_report(path: str) -> dict:
     """Load and parse a pytest-json-report file.
-    
+
     Args:
         path: Path to pytest JSON report file
-        
+
     Returns:
         Parsed report data dictionary
-        
+
     Raises:
         SystemExit: On file not found or invalid JSON
     """
@@ -78,10 +78,10 @@ LAYER_ORDER = {
 
 def extract_layer(path: str) -> str:
     """Extract the architectural layer from a file path.
-    
+
     Args:
         path: File path to analyze
-        
+
     Returns:
         Layer name (e.g., "Domain", "Application", "Other")
     """
@@ -94,19 +94,19 @@ def extract_layer(path: str) -> str:
 
 def build_suffix_index(radon_map: dict) -> dict:
     """Build a suffix-keyed index for path matching.
-    
-    This allows matching coverage.json paths (which may use different root 
+
+    This allows matching coverage.json paths (which may use different root
     prefixes or be absolute vs relative) to radon output.
-    
+
     Strategy: for each radon key, store it under every possible suffix:
       '/home/user/proj/app/foo/bar.py'  →  keys: 'bar.py', 'foo/bar.py',
                                             'app/foo/bar.py', ...
     Then look up a coverage path by trying progressively longer suffixes
     until one hits. The longest match wins to avoid false collisions.
-    
+
     Args:
         radon_map: Dictionary mapping file paths to radon analysis data
-        
+
     Returns:
         Dictionary mapping suffixes to radon values
     """
@@ -123,13 +123,13 @@ def build_suffix_index(radon_map: dict) -> dict:
 
 def suffix_lookup(index: dict, coverage_path: str):
     """Look up a coverage.json path in a suffix index.
-    
+
     Try suffixes from most-specific (full path) down to basename.
-    
+
     Args:
         index: Index built by build_suffix_index()
         coverage_path: Path from coverage.json to look up
-        
+
     Returns:
         The radon value if found, None otherwise
     """
@@ -149,17 +149,17 @@ def precompute_coverage_stats(
     hal_map: dict = None,
 ) -> dict:
     """Precompute statistics from coverage.json and radon data.
-    
+
     One pass over data['files']. Returns everything both histogram and
     list functions need so neither has to re-iterate the JSON.
-    
+
     Args:
         data: Parsed coverage.json data
         complexity_map: Radon cyclomatic complexity data (optional)
         mi_map: Radon maintainability index data (optional)
         raw_map: Radon raw metrics data (optional)
         hal_map: Radon Halstead metrics data (optional)
-        
+
     Returns:
         Dictionary with precomputed statistics including file_stats, project totals,
         and coverage percentiles

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/coverage.py

@@ -1,15 +1,16 @@
 """Coverage analysis functions."""
 
 from pathlib import Path
-from .utils import percentile, format_line_ranges, ascii_histogram, blame_header
+
+from .utils import ascii_histogram, blame_header, format_line_ranges, percentile
 
 
 def scan_pragma_intervals(root: str) -> dict[str, list]:
     """Find sequential # pragma: no cover blocks per .py file under root.
-    
+
     Args:
         root: Root directory to scan
-        
+
     Returns:
         Dictionary mapping file paths to lists of (start, end) tuples
     """
@@ -40,10 +41,10 @@ def scan_pragma_intervals(root: str) -> dict[str, list]:
 
 def scan_pragma_counts(root: str) -> dict[str, int]:
     """Count '# pragma: no cover' occurrences per .py file under root.
-    
+
     Args:
         root: Root directory to scan
-        
+
     Returns:
         Dictionary mapping file paths to pragma counts
     """
@@ -60,12 +61,14 @@ def scan_pragma_counts(root: str) -> dict[str, int]:
     return result
 
 
-def show_pragma_histogram(pragma_counts: dict, bins: int = 10, blame_limit: int = 20, width: int = 80) -> None:
+def show_pragma_histogram(
+    pragma_counts: dict, bins: int = 10, blame_limit: int = 20, width: int = 80
+) -> None:
     """Histogram of '# pragma: no cover' count per file + all-files listing.
 
     Also prints a secondary histogram and table for sequential blocks of
     pragmas (intervals) so that you can spot long runs of skipped code.
-    
+
     Args:
         pragma_counts: Dictionary mapping files to pragma counts
         bins: Number of histogram bins
@@ -173,7 +176,7 @@ def show_coverage_histogram(
     width: int = 80,
 ):
     """Display coverage distribution histogram and low-coverage blame.
-    
+
     Args:
         stats: Precomputed statistics from precompute_coverage_stats()
         bins: Number of histogram bins
@@ -228,6 +231,7 @@ def show_coverage_histogram(
     missing_counts = sorted(f["missing_count"] for f in stats["file_stats"] if f["pct"] < 100.0)
     if missing_counts:
         import math
+
         nm = len(missing_counts)
         total_missing = sum(missing_counts)
         m_max = missing_counts[-1]
@@ -282,7 +286,9 @@ def show_coverage_histogram(
             ],
             key=lambda x: x[0],
         )
-        blame_header(f"below {blame_ceiling:.1f}% ({boundary_note})", len(blamed), blame_limit, width)
+        blame_header(
+            f"below {blame_ceiling:.1f}% ({boundary_note})", len(blamed), blame_limit, width
+        )
         display = blamed if not blame_limit else blamed[:blame_limit]
         if display:
             for pct, path, missing_count, missing_lines in display:

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/duration.py

@@ -1,17 +1,18 @@
 """Test duration and performance analysis."""
 
 import math
-from .utils import percentile, fmt_seconds, ascii_histogram, blame_header
+
+from .utils import ascii_histogram, blame_header, fmt_seconds, percentile
 
 
 def test_duration(t: dict):
     """Get (total_duration, breakdown_dict) for a test.
-    
+
     Sum setup, call and teardown phases.
-    
+
     Args:
         t: Test dictionary from pytest-json-report
-        
+
     Returns:
         Tuple of (total_duration_seconds, phase_breakdown_dict)
     """
@@ -32,7 +33,7 @@ def test_duration(t: dict):
 
 def render_duration_stats(ds: list, slow_threshold: float, width: int = 80):
     """Render summary statistics for a duration list.
-    
+
     Args:
         ds: Sorted list of durations
         slow_threshold: Threshold for considering tests slow
@@ -67,7 +68,7 @@ def render_duration_histogram_core(
     width: int = 80,
 ):
     """Render the ASCII histogram for a duration list.
-    
+
     Args:
         ds: Sorted list of durations
         title: Title for the histogram
@@ -138,7 +139,7 @@ def show_duration_histogram(
     width: int = 80,
 ):
     """Display test duration histogram and slow test blame.
-    
+
     Args:
         report: Parsed pytest-json-report data
         bins: Number of histogram bins
@@ -181,7 +182,9 @@ def show_duration_histogram(
     report_total = report.get("duration", 0)
     collection_time = report_total - total if report_total > total else 0
 
-    print(f"  Tests: {n}   Total: {fmt_seconds(total)} ({fmt_seconds(report_total)} wall time)   {outcome_str}")
+    print(
+        f"  Tests: {n}   Total: {fmt_seconds(total)} ({fmt_seconds(report_total)} wall time)   {outcome_str}"
+    )
     if collection_time > 1:
         print(f"           (includes ~{fmt_seconds(collection_time)} collection/overhead)")
 
@@ -194,7 +197,9 @@ def show_duration_histogram(
 
     # 2. Show call histogram
     if phases["call"]:
-        render_duration_histogram_core(sorted(phases["call"]), "PHASE: CALL", bins, slow_threshold, width)
+        render_duration_histogram_core(
+            sorted(phases["call"]), "PHASE: CALL", bins, slow_threshold, width
+        )
         print(f"\n  {'-' * (width - 4)}")
 
     # 3. Show teardown histogram
@@ -205,7 +210,9 @@ def show_duration_histogram(
         print(f"\n  {'-' * (width - 4)}")
 
     # 4. Show total duration histogram
-    render_duration_histogram_core(durations, "AGGREGATE: TOTAL DURATION", bins, slow_threshold, width)
+    render_duration_histogram_core(
+        durations, "AGGREGATE: TOTAL DURATION", bins, slow_threshold, width
+    )
 
     if show_blame:
         q1_dur = percentile(durations, 25)

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/lowcov.py

@@ -1,19 +1,18 @@
 """Low-coverage file listing and prioritization."""
 
-from .utils import format_line_ranges
 from .metrics import cc_rank, mi_rank
-
+from .utils import format_line_ranges
 
 VALID_SORT_FIELDS = {"priority", "coverage", "layer", "missing", "missing_pct", "complexity"}
 
 
 def parse_sorts(sort_specs: list, default_order: str) -> list:
     """Parse sort specifications into (field, is_descending) tuples.
-    
+
     Args:
         sort_specs: List of sort specs like ["priority:desc", "coverage:asc"]
         default_order: Default sort order ("asc" or "desc")
-        
+
     Returns:
         List of (field, is_descending) tuples
     """
@@ -32,16 +31,18 @@ def parse_sorts(sort_specs: list, default_order: str) -> list:
     return result
 
 
-def priority_score(pct: float, layer: str, missing: int, cc_avg: float = None, mi: float = None) -> int:
+def priority_score(
+    pct: float, layer: str, missing: int, cc_avg: float = None, mi: float = None
+) -> int:
     """Calculate priority score for a file based on coverage and metrics.
-    
+
     Args:
         pct: Coverage percentage
         layer: Architectural layer
         missing: Number of missing statements
         cc_avg: Average cyclomatic complexity (optional)
         mi: Maintainability index (optional)
-        
+
     Returns:
         Priority score (higher = more important to fix)
     """
@@ -68,7 +69,7 @@ def show_low_coverage(
     width: int = 100,
 ):
     """Display files with low coverage and quality metrics.
-    
+
     Args:
         stats: Precomputed statistics from precompute_coverage_stats()
         threshold: Show files below this coverage percentage

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/metrics.py

@@ -1,25 +1,16 @@
 """Code quality metrics analysis (complexity, maintainability, etc.)."""
 
 import bisect
-from .utils import percentile, format_line_ranges, ascii_histogram, blame_header
+
 from .radon import (  # re-export so callers can still import from here
     cc_rank,
     mi_rank,
-    run_radon_json,
     run_radon,
     run_radon_mi,
     run_radon_raw,
     run_radon_hal,
-    _HAL_VOLUME,
-    _HAL_DIFFICULTY,
-    _HAL_EFFORT,
-    _HAL_BUGS,
-    _parse_hal_list,
-    _parse_hal_dict,
-    _parse_hal_entry,
-    _run_hal_chunk,
-    _collect_hal_raw,
 )
+from .utils import ascii_histogram, blame_header, format_line_ranges, percentile
 
 
 def _float_buckets(sorted_values: list, n_bins: int) -> tuple:
@@ -109,9 +100,7 @@ def _blame_raw(raw_files: list, q1_ratio: float, blame_limit: int, width: int) -
         [f for f in raw_files if f[0] < q1_ratio],
         key=lambda x: x[0],
     )
-    blame_header(
-        f"comment ratio below Q1 ({q1_ratio * 100:.1f}%)", len(blamed), blame_limit, width
-    )
+    blame_header(f"comment ratio below Q1 ({q1_ratio * 100:.1f}%)", len(blamed), blame_limit, width)
     display = blamed if not blame_limit else blamed[:blame_limit]
     if display:
         print(f"  {'Comment%':<10}  {'SLOC':<7}  {'Coverage':<10}  File")
@@ -289,7 +278,7 @@ def show_raw_histogram(
     stats: dict, bins: int = 10, blame_limit: int = 20, show_blame: bool = True, width: int = 80
 ):
     """Display comment ratio histogram and under-documented blame.
-    
+
     Args:
         stats: Precomputed statistics from precompute_coverage_stats()
         bins: Number of histogram bins
@@ -343,7 +332,7 @@ def show_hal_histogram(
     stats: dict, bins: int = 10, blame_limit: int = 20, show_blame: bool = True, width: int = 80
 ):
     """Display Halstead metrics histogram and bug-prone file blame.
-    
+
     Args:
         stats: Precomputed statistics from precompute_coverage_stats()
         bins: Number of histogram bins
@@ -391,3 +380,17 @@ def show_hal_histogram(
         threshold = q3_b + 1.5 * (q3_b - q1_b)
         _blame_hal(hal_files, threshold, blame_limit, width)
     print(f"\n{'═' * width}")
+
+
+# Re-export Halstead constants and helpers for backward compatibility
+from .radon import (  # noqa: E402
+    _HAL_VOLUME,
+    _HAL_DIFFICULTY,
+    _HAL_EFFORT,
+    _HAL_BUGS,
+    _parse_hal_list,
+    _parse_hal_dict,
+    _parse_hal_entry,
+    _run_hal_chunk,
+    run_radon_json,
+)

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/radon.py

@@ -8,10 +8,26 @@ from pathlib import Path
 # Cyclomatic Complexity rank thresholds (McCabe scale)
 # A: 1–5  B: 6–10  C: 11–15  D: 16–20  E: 21–25  F: 26+
 _CC_RISK = {
-    1: "A", 2: "A", 3: "A", 4: "A", 5: "A",
-    6: "B", 7: "B", 8: "B", 9: "B", 10: "B",
-    11: "C", 12: "C", 13: "C", 14: "C", 15: "C",
-    16: "D", 17: "D", 18: "D", 19: "D", 20: "D",
+    1: "A",
+    2: "A",
+    3: "A",
+    4: "A",
+    5: "A",
+    6: "B",
+    7: "B",
+    8: "B",
+    9: "B",
+    10: "B",
+    11: "C",
+    12: "C",
+    13: "C",
+    14: "C",
+    15: "C",
+    16: "D",
+    17: "D",
+    18: "D",
+    19: "D",
+    20: "D",
 }
 
 
@@ -65,6 +81,7 @@ def run_radon_json(subcmd: str, root: str, extra_flags: list = None, debug: bool
         print(f"⚠️  radon {subcmd} failed: {e}")
         if debug:
             import traceback
+
             traceback.print_exc()
         return {}
 
@@ -247,8 +264,7 @@ def run_radon_hal(root: str, debug: bool = False) -> dict:
         print(f"⚠️  radon hal: path does not exist: {root_path}")
         return {}
     py_files = sorted(
-        str(p) for p in root_path.rglob("*.py")
-        if not any(part.startswith(".") for part in p.parts)
+        str(p) for p in root_path.rglob("*.py") if not any(part.startswith(".") for part in p.parts)
     )
     if not py_files:
         print(f"⚠️  radon hal: no .py files found under {root_path}")

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/reporter.py

@@ -12,7 +12,7 @@ from .core import (
     precompute_coverage_stats,
 )
 from .coverage import scan_pragma_counts
-from .metrics import (
+from .radon import (
     run_radon,
     run_radon_mi,
     run_radon_raw,

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/sizes.py

@@ -1,7 +1,8 @@
 """File size distribution analysis."""
 
 from pathlib import Path
-from .utils import percentile, ascii_histogram, blame_header
+
+from .utils import ascii_histogram, blame_header, percentile
 
 
 def show_file_size_distribution(
@@ -15,7 +16,7 @@ def show_file_size_distribution(
     width: int = 80,
 ):
     """Display file size distribution histogram.
-    
+
     Args:
         root: Root directory to scan
         extension: File extension to analyze
@@ -88,7 +89,10 @@ def show_file_size_distribution(
             [(lc, fp) for lc, fp in files if lc > iqr_lines], key=lambda x: x[0], reverse=True
         )
         blame_header(
-            f"size outliers  Q3 + 1.5×IQR > {iqr_lines} lines", len(blamed_files), blame_limit, width
+            f"size outliers  Q3 + 1.5×IQR > {iqr_lines} lines",
+            len(blamed_files),
+            blame_limit,
+            width,
         )
         display = blamed_files if not blame_limit else blamed_files[:blame_limit]
         if display:

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/tree.py

@@ -2,14 +2,15 @@
 
 import os
 from pathlib import Path
-from .utils import percentile, ascii_histogram, blame_header
+
+from .utils import ascii_histogram, blame_header, percentile
 
 
 def analyze_tree(root_path: str, bins: int = 10, blame_limit: int = 20, width: int = 80):
     """Analyze file tree structure, collecting metrics per directory.
-    
+
     Displays statistics and histograms about file and folder distribution.
-    
+
     Args:
         root_path: Root directory to analyze
         bins: Number of histogram bins
@@ -132,7 +133,10 @@ def analyze_tree(root_path: str, bins: int = 10, blame_limit: int = 20, width: i
         )
 
         blame_header(
-            f"subfolder count outliers (Q3+1.5×IQR > {boundary_d:g})", len(blamed_d), blame_limit, width
+            f"subfolder count outliers (Q3+1.5×IQR > {boundary_d:g})",
+            len(blamed_d),
+            blame_limit,
+            width,
         )
         display_d = blamed_d if not blame_limit else blamed_d[:blame_limit]
         if display_d:

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats/utils.py

@@ -1,6 +1,5 @@
 """Shared utility functions for codebase analysis."""
 
-import math
 
 
 def percentile(sorted_vals: list, pct: int):
@@ -12,10 +11,10 @@ def percentile(sorted_vals: list, pct: int):
 
 def format_line_ranges(lines: list) -> str:
     """Convert a list of line numbers into a human-readable ranges string.
-    
+
     Args:
         lines: List of line numbers
-        
+
     Returns:
         String like "1-5, 10, 15-18"
     """
@@ -37,7 +36,7 @@ def ascii_histogram(
     counts: list, labels: list, bar_width: int = 36, suffixes: list = None, width: int = 80
 ) -> None:
     """Print a fixed-width ASCII histogram.
-    
+
     Args:
         counts: List of counts for each bar
         labels: List of labels for each bar
@@ -57,7 +56,7 @@ def ascii_histogram(
 
 def blame_header(label: str, total: int, limit: int, width: int = 80) -> None:
     """Print a blame section header.
-    
+
     Args:
         label: Description of what's being blamed
         total: Total number of blamed items
@@ -72,7 +71,7 @@ def blame_header(label: str, total: int, limit: int, width: int = 80) -> None:
 
 def fmt_seconds(seconds: float) -> str:
     """Format seconds into human-readable time string.
-    
+
     Examples:
         0.5 -> "500ms"
         1.5 -> "1.50s"

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebase-stats
-Version: 0.0.1
+Version: 0.0.2
 Summary: Comprehensive codebase analysis library with coverage, metrics, and test duration analysis
 Author-email: Your Name <your.email@example.com>
 License: MIT

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/codebase_stats.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 codebase_stats/__init__.py
+codebase_stats/cli.py
 codebase_stats/core.py
 codebase_stats/coverage.py
 codebase_stats/duration.py

codebase_stats-0.0.2/codebase_stats.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codebase-stats = codebase_stats.cli:main

{codebase_stats-0.0.1 → codebase_stats-0.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codebase-stats"
-version = "0.0.1"
+version = "0.0.2"
 description = "Comprehensive codebase analysis library with coverage, metrics, and test duration analysis"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -102,7 +102,6 @@ ignore = [
 
 [tool.ruff.lint.isort]
 known-first-party = ["codebase_stats"]
-profile = "black"
 
 [tool.mypy]
 python_version = "3.9"
@@ -112,7 +111,7 @@ disallow_untyped_defs = false
 ignore_missing_imports = true
 
 [project.scripts]
-codebase-stats = "cli:main"
+codebase-stats = "codebase_stats.cli:main"
 
 [tool.setuptools]
 packages = ["codebase_stats"]

codebase_stats-0.0.1/codebase_stats.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-codebase-stats = cli:main