Fabian
1907 lines
79 KiB
Python
1907 lines
79 KiB
Python
#!/usr/bin/env python3
|
|
import gc
|
|
import os
|
|
import re
|
|
import sys
|
|
import json
|
|
import time
|
|
import argparse
|
|
import statistics
|
|
import subprocess
|
|
import platform
|
|
from pathlib import Path
|
|
from collections import defaultdict
|
|
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, wait, FIRST_COMPLETED
|
|
import fnmatch
|
|
|
|
VERSION = "2.1.2"
|
|
|
|
# Windows Terminal Fix for ANSI codes
|
|
if sys.platform == "win32":
|
|
os.system("")
|
|
|
|
# Ensure UTF-8 output on Windows
|
|
if sys.stdout.encoding != 'utf-8':
|
|
sys.stdout.reconfigure(encoding='utf-8', errors='replace')
|
|
if sys.stderr.encoding != 'utf-8':
|
|
sys.stderr.reconfigure(encoding='utf-8', errors='replace')
|
|
|
|
HELP_TEXT = """pjstats - Enhanced project statistics with multi-threaded analysis.
|
|
|
|
Usage examples:
|
|
python3 pjstats.py
|
|
python3 pjstats.py /path/to/project --top 10 --json > pjstats.json
|
|
python3 pjstats.py --ext .py .js --min-code-lines 10
|
|
python3 pjstats.py --exclude language_model .git
|
|
python3 pjstats.py --no-color --no-git
|
|
python3 pjstats.py --workers 4 --no-animation
|
|
|
|
Options:
|
|
path Project root (default: .)
|
|
--json Output JSON summary
|
|
--top N Top N files to display (default: 5)
|
|
--ext Limit to specific extensions (e.g. .py .js)
|
|
--min-code-lines Ignore files with fewer code lines than this
|
|
--exclude Directories to ignore recursively (relative to project root)
|
|
--include-hidden Include hidden directories/files
|
|
--no-color Disable color output
|
|
--no-git Disable Git info detection
|
|
--no-animation Disable startup animation and progress bars
|
|
--bypass-excluded Bypass all ignore rules (.gitignore, built-in excludes, etc.)
|
|
--workers N Number of threads for parallel analysis (0=auto)
|
|
|
|
Notes:
|
|
- Files named Dockerfile.* are treated as Dockerfiles.
|
|
- Languages without a comment token (e.g., Markdown, JSON) are shown as N/A in the Code Quality Snapshot.
|
|
- The installer chooses a sensible default install directory for your OS (Unix: ~/.local/bin, Windows: %LOCALAPPDATA%/Programs/pjstats or %USERPROFILE%/Scripts) if `--install-dir` is not specified.
|
|
|
|
"""
|
|
|
|
# --------------------------------------------------
|
|
# Configuration
|
|
# --------------------------------------------------
|
|
|
|
# files to check for ignore patterns
|
|
IGNORE_FILES_TO_CHECK = ['.gitignore', '.ignore', '.dockerignore', '.npmignore']
|
|
|
|
CODE_LANGUAGES = {
|
|
# JavaScript / TypeScript
|
|
".js": ("JavaScript", "//", "code"),
|
|
".jsx": ("JavaScript (JSX)", "//", "code"),
|
|
".ts": ("TypeScript", "//", "code"),
|
|
".tsx": ("TypeScript (TSX)", "//", "code"),
|
|
".mjs": ("JavaScript (ESM)", "//", "code"),
|
|
".cjs": ("JavaScript (CJS)", "//", "code"),
|
|
# Python
|
|
".py": ("Python", "#", "code"),
|
|
".pyw": ("Python", "#", "code"),
|
|
".pyi": ("Python Stub", "#", "code"),
|
|
# Shell
|
|
".sh": ("Shell", "#", "code"),
|
|
".bash": ("Bash", "#", "code"),
|
|
".zsh": ("Zsh", "#", "code"),
|
|
".fish": ("Fish", "#", "code"),
|
|
".ksh": ("KornShell", "#", "code"),
|
|
# PowerShell
|
|
".ps1": ("PowerShell", "#", "code"),
|
|
".psm1": ("PowerShell Module", "#", "code"),
|
|
".psd1": ("PowerShell Data", "#", "code"),
|
|
# Batch / CMD
|
|
".bat": ("Batch", "REM", "code"),
|
|
".cmd": ("Batch", "REM", "code"),
|
|
# Web
|
|
".html": ("HTML", "<!--", "code"),
|
|
".htm": ("HTML", "<!--", "code"),
|
|
".css": ("CSS", "/*", "code"),
|
|
".scss": ("SCSS", "//", "code"),
|
|
".sass": ("Sass", "//", "code"),
|
|
".less": ("Less", "//", "code"),
|
|
".styl": ("Stylus", "//", "code"),
|
|
# Web Frameworks
|
|
".vue": ("Vue", "//", "code"),
|
|
".svelte": ("Svelte", "//", "code"),
|
|
".astro": ("Astro", "//", "code"),
|
|
# Dart / Flutter
|
|
".dart": ("Dart", "//", "code"),
|
|
# C-Family
|
|
".c": ("C", "//", "code"),
|
|
".h": ("C Header", "//", "code"),
|
|
".cpp": ("C++", "//", "code"),
|
|
".hpp": ("C++ Header", "//", "code"),
|
|
".cc": ("C++", "//", "code"),
|
|
".cxx": ("C++", "//", "code"),
|
|
".hxx": ("C++ Header", "//", "code"),
|
|
".c++": ("C++", "//", "code"),
|
|
".h++": ("C++ Header", "//", "code"),
|
|
".cs": ("C#", "//", "code"),
|
|
".m": ("Objective-C", "//", "code"),
|
|
".mm": ("Objective-C++", "//", "code"),
|
|
# Java / JVM
|
|
".java": ("Java", "//", "code"),
|
|
".kt": ("Kotlin", "//", "code"),
|
|
".kts": ("Kotlin Script", "//", "code"),
|
|
".groovy": ("Groovy", "//", "code"),
|
|
".scala": ("Scala", "//", "code"),
|
|
".clj": ("Clojure", ";;", "code"),
|
|
".cljs": ("ClojureScript", ";;", "code"),
|
|
".cljc": ("Clojure", ";;", "code"),
|
|
# Apple / iOS
|
|
".swift": ("Swift", "//", "code"),
|
|
# Build systems
|
|
".gradle": ("Gradle", "//", "code"),
|
|
".cmake": ("CMake", "#", "code"),
|
|
# Go
|
|
".go": ("Go", "//", "code"),
|
|
# Rust
|
|
".rs": ("Rust", "//", "code"),
|
|
# PHP
|
|
".php": ("PHP", "//", "code"),
|
|
# Ruby
|
|
".rb": ("Ruby", "#", "code"),
|
|
".rake": ("Ruby", "#", "code"),
|
|
".gemspec": ("Ruby", "#", "code"),
|
|
# Lua
|
|
".lua": ("Lua", "--", "code"),
|
|
# SQL
|
|
".sql": ("SQL", "--", "code"),
|
|
# R
|
|
".r": ("R", "#", "code"),
|
|
".R": ("R", "#", "code"),
|
|
".rmd": ("R Markdown", "#", "code"),
|
|
# Perl
|
|
".pl": ("Perl", "#", "code"),
|
|
".pm": ("Perl", "#", "code"),
|
|
".t": ("Perl Test", "#", "code"),
|
|
# Elixir / Erlang
|
|
".ex": ("Elixir", "#", "code"),
|
|
".exs": ("Elixir Script", "#", "code"),
|
|
".erl": ("Erlang", "%", "code"),
|
|
".hrl": ("Erlang Header", "%", "code"),
|
|
# Haskell
|
|
".hs": ("Haskell", "--", "code"),
|
|
".lhs": ("Literate Haskell", "--", "code"),
|
|
# OCaml
|
|
".ml": ("OCaml", "(*", "code"),
|
|
".mli": ("OCaml Interface", "(*", "code"),
|
|
# F#
|
|
".fs": ("F#", "//", "code"),
|
|
".fsx": ("F# Script", "//", "code"),
|
|
".fsi": ("F# Signature", "//", "code"),
|
|
# Nim
|
|
".nim": ("Nim", "#", "code"),
|
|
".nims": ("Nim Script", "#", "code"),
|
|
# Zig
|
|
".zig": ("Zig", "//", "code"),
|
|
# V
|
|
".v": ("V", "//", "code"),
|
|
# Crystal
|
|
".cr": ("Crystal", "#", "code"),
|
|
# Julia
|
|
".jl": ("Julia", "#", "code"),
|
|
# Elm
|
|
".elm": ("Elm", "--", "code"),
|
|
# PureScript
|
|
".purs": ("PureScript", "--", "code"),
|
|
# Fortran
|
|
".f": ("Fortran", "!", "code"),
|
|
".f90": ("Fortran", "!", "code"),
|
|
".f95": ("Fortran", "!", "code"),
|
|
".f03": ("Fortran", "!", "code"),
|
|
".f08": ("Fortran", "!", "code"),
|
|
".for": ("Fortran", "!", "code"),
|
|
# COBOL
|
|
".cob": ("COBOL", "*", "code"),
|
|
".cbl": ("COBOL", "*", "code"),
|
|
# Pascal / Delphi
|
|
".pas": ("Pascal", "//", "code"),
|
|
".dpr": ("Delphi", "//", "code"),
|
|
".dpk": ("Delphi", "//", "code"),
|
|
# D
|
|
".d": ("D", "//", "code"),
|
|
# Ada
|
|
".adb": ("Ada", "--", "code"),
|
|
".ads": ("Ada", "--", "code"),
|
|
# Lisp / Scheme / Racket
|
|
".lisp": ("Lisp", ";;", "code"),
|
|
".lsp": ("Lisp", ";;", "code"),
|
|
".cl": ("Common Lisp", ";;", "code"),
|
|
".scm": ("Scheme", ";;", "code"),
|
|
".ss": ("Scheme", ";;", "code"),
|
|
".rkt": ("Racket", ";;", "code"),
|
|
# Prolog
|
|
".pro": ("Prolog", "%", "code"),
|
|
# Tcl
|
|
".tcl": ("Tcl", "#", "code"),
|
|
# VB.NET / VBScript
|
|
".vb": ("VB.NET", "'", "code"),
|
|
".vbs": ("VBScript", "'", "code"),
|
|
# Assembly
|
|
".asm": ("Assembly", ";", "code"),
|
|
".s": ("Assembly", ";", "code"),
|
|
# VHDL / SystemVerilog
|
|
".vhd": ("VHDL", "--", "code"),
|
|
".vhdl": ("VHDL", "--", "code"),
|
|
".sv": ("SystemVerilog", "//", "code"),
|
|
".svh": ("SystemVerilog Header", "//", "code"),
|
|
# CoffeeScript
|
|
".coffee": ("CoffeeScript", "#", "code"),
|
|
# Handlebars
|
|
".hbs": ("Handlebars", "{{!--", "code"),
|
|
# Solidity
|
|
".sol": ("Solidity", "//", "code"),
|
|
# Terraform / HCL
|
|
".tf": ("Terraform", "#", "code"),
|
|
".tfvars": ("Terraform Vars", "#", "code"),
|
|
".hcl": ("HCL", "#", "code"),
|
|
# Nix
|
|
".nix": ("Nix", "#", "code"),
|
|
# GraphQL
|
|
".graphql": ("GraphQL", "#", "code"),
|
|
".gql": ("GraphQL", "#", "code"),
|
|
# Protocol Buffers / Thrift
|
|
".proto": ("Protobuf", "//", "code"),
|
|
".thrift": ("Thrift", "//", "code"),
|
|
# AWK
|
|
".awk": ("AWK", "#", "code"),
|
|
# Gleam
|
|
".gleam": ("Gleam", "//", "code"),
|
|
# Mojo
|
|
".mojo": ("Mojo", "#", "code"),
|
|
# Odin
|
|
".odin": ("Odin", "//", "code"),
|
|
# Wren
|
|
".wren": ("Wren", "//", "code"),
|
|
# ReScript / Reason
|
|
".res": ("ReScript", "//", "code"),
|
|
".resi": ("ReScript Interface", "//", "code"),
|
|
".re": ("Reason", "//", "code"),
|
|
".rei": ("Reason Interface", "//", "code"),
|
|
# Apex (Salesforce)
|
|
".cls": ("Apex", "//", "code"),
|
|
".trigger": ("Apex Trigger", "//", "code"),
|
|
# CUDA
|
|
".cu": ("CUDA", "//", "code"),
|
|
".cuh": ("CUDA Header", "//", "code"),
|
|
# Hack
|
|
".hack": ("Hack", "//", "code"),
|
|
# Jsonnet
|
|
".jsonnet": ("Jsonnet", "//", "code"),
|
|
".libsonnet": ("Jsonnet", "//", "code"),
|
|
# Dhall
|
|
".dhall": ("Dhall", "--", "code"),
|
|
# Starlark (Bazel)
|
|
".bzl": ("Starlark", "#", "code"),
|
|
".star": ("Starlark", "#", "code"),
|
|
}
|
|
|
|
CONFIG_LANGUAGES = {
|
|
".json": ("JSON", None, "config"),
|
|
".jsonc": ("JSON with Comments", "//", "config"),
|
|
".json5": ("JSON5", "//", "config"),
|
|
".yml": ("YAML", "#", "config"),
|
|
".yaml": ("YAML", "#", "config"),
|
|
# Flutter / Dart config
|
|
".arb": ("ARB (Flutter i18n)", None, "config"),
|
|
".pubspec": ("Pubspec", "#", "config"),
|
|
# Build / Project config
|
|
".xml": ("XML", "<!--", "config"),
|
|
".plist": ("Property List", "<!--", "config"),
|
|
".iml": ("IntelliJ Module", "<!--", "config"),
|
|
".properties": ("Properties", "#", "config"),
|
|
".env": ("Environment", "#", "config"),
|
|
".toml": ("TOML", "#", "config"),
|
|
".ini": ("INI", ";", "config"),
|
|
".cfg": ("Config", "#", "config"),
|
|
".conf": ("Config", "#", "config"),
|
|
# Lock files
|
|
".lock": ("Lock File", "#", "config"),
|
|
# Editor / VCS config
|
|
".editorconfig": ("EditorConfig", "#", "config"),
|
|
".gitignore": ("Git Ignore", "#", "config"),
|
|
".gitattributes": ("Git Attributes", "#", "config"),
|
|
".dockerignore": ("Docker Ignore", "#", "config"),
|
|
# Data formats
|
|
".csv": ("CSV", None, "config"),
|
|
".tsv": ("TSV", None, "config"),
|
|
# EDN (Clojure data)
|
|
".edn": ("EDN", ";;", "config"),
|
|
}
|
|
|
|
DOC_LANGUAGES = {
|
|
".md": ("Markdown", None, "docs"),
|
|
".rst": ("reStructuredText", None, "docs"),
|
|
".txt": ("Text", None, "docs"),
|
|
".adoc": ("AsciiDoc", None, "docs"),
|
|
".tex": ("LaTeX", "%", "docs"),
|
|
".org": ("Org Mode", None, "docs"),
|
|
".wiki": ("Wiki", None, "docs"),
|
|
".rdoc": ("RDoc", None, "docs"),
|
|
}
|
|
|
|
IGNORE_DIRECTORIES = {
|
|
".git", "node_modules", "__pycache__", "dist",
|
|
"build", ".venv", "backup", "backups", ".idea", ".vscode", ".pytest_cache",
|
|
".env", ".eggs", "venv", "env", ".tox", ".mypy_cache", ".ruff_cache",
|
|
".claude", ".openai", "logs", "log", "tmp", "temp", ".githooks",
|
|
# Flutter / Dart specific
|
|
".dart_tool", ".pub-cache", ".pub", "ephemeral", ".symlinks",
|
|
"Pods", "DerivedData", "xcuserdata", ".gradle",
|
|
# Additional
|
|
"vendor", "target", "out", "bin", "obj", "packages", "cache",
|
|
"site-packages", "virtualenv", ".cache", ".next", ".nuxt",
|
|
".svn", ".hg", "bower_components", ".terraform",
|
|
".serverless", "__MACOSX", "coverage", ".coverage",
|
|
".nyc_output", "htmlcov", "_build", ".build", ".sass-cache",
|
|
}
|
|
|
|
IGNORE_FILE_PATTERNS = (
|
|
"package-lock.json",
|
|
"yarn.lock",
|
|
"pnpm-lock.yaml",
|
|
"composer.lock",
|
|
"Gemfile.lock",
|
|
"Cargo.lock",
|
|
"poetry.lock",
|
|
".min.js",
|
|
".min.css",
|
|
".map",
|
|
".bundle.",
|
|
".chunk.",
|
|
)
|
|
|
|
# --------------------------------------------------
|
|
# Terminal Styling
|
|
# --------------------------------------------------
|
|
|
|
RESET = "\033[0m"
|
|
BOLD = "\033[1m"
|
|
DIM = "\033[2m"
|
|
BLUE = "\033[38;5;75m"
|
|
GREEN = "\033[38;5;114m"
|
|
ORANGE = "\033[38;5;215m"
|
|
RED = "\033[38;5;203m"
|
|
CYAN = "\033[38;5;117m"
|
|
MAGENTA = "\033[38;5;183m"
|
|
YELLOW = "\033[38;5;229m"
|
|
WHITE = "\033[38;5;255m"
|
|
PURPLE = "\033[38;5;141m"
|
|
PINK = "\033[38;5;218m"
|
|
TEAL = "\033[38;5;80m"
|
|
|
|
# Animation-specific colors
|
|
HIDE_CURSOR = "\033[?25l"
|
|
SHOW_CURSOR = "\033[?25h"
|
|
GRAD = ["\033[38;5;51m", "\033[38;5;50m", "\033[38;5;49m", "\033[38;5;48m", "\033[38;5;47m", "\033[38;5;46m"]
|
|
GOLD = "\033[38;5;220m"
|
|
DARKGRAY = "\033[38;5;240m"
|
|
GRAY = "\033[38;5;245m"
|
|
|
|
LOGO = r"""
|
|
██████╗ ██╗███████╗████████╗ █████╗ ████████╗███████╗
|
|
██╔══██╗ ██║██╔════╝╚══██╔══╝██╔══██╗╚══██╔══╝██╔════╝
|
|
██████╔╝ ██║███████╗ ██║ ███████║ ██║ ███████╗
|
|
██╔═══╝ ██ ██║╚════██║ ██║ ██╔══██║ ██║ ╚════██║
|
|
██║ ╚█████╔╝███████║ ██║ ██║ ██║ ██║ ███████║
|
|
╚═╝ ╚════╝ ╚══════╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚══════╝
|
|
"""
|
|
|
|
# --------------------------------------------------
|
|
# Animation & Progress
|
|
# --------------------------------------------------
|
|
|
|
def get_term_width():
|
|
try:
|
|
return os.get_terminal_size().columns
|
|
except Exception:
|
|
return 80
|
|
|
|
|
|
def clear_screen():
|
|
sys.stdout.write("\033[2J\033[H")
|
|
sys.stdout.flush()
|
|
|
|
|
|
def print_centered(text, color=""):
|
|
width = get_term_width()
|
|
clean = re.sub(r'\033\[[0-9;]*m', '', text)
|
|
padding = (width - len(clean)) // 2
|
|
print(" " * max(0, padding) + color + text + RESET)
|
|
|
|
|
|
def animate_logo():
|
|
sys.stdout.write(HIDE_CURSOR)
|
|
clear_screen()
|
|
lines = LOGO.strip().split('\n')
|
|
width = get_term_width()
|
|
print()
|
|
for i, line in enumerate(lines):
|
|
color = GRAD[i % len(GRAD)]
|
|
padding = (width - len(line)) // 2
|
|
sys.stdout.write(" " * max(0, padding) + color + line + RESET + "\n")
|
|
sys.stdout.flush()
|
|
time.sleep(0.05)
|
|
print()
|
|
print_centered("━━━ Project Statistics Analyzer ━━━", GRAY)
|
|
time.sleep(0.1)
|
|
print_centered(f"v{VERSION} │ Multi-Threaded Analytics", DARKGRAY)
|
|
print()
|
|
time.sleep(0.2)
|
|
|
|
|
|
def loading_animation(text, duration=0.5, style="dots"):
|
|
frames = {
|
|
"dots": ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
|
|
"blocks": ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█", "▇", "▆", "▅", "▄", "▃", "▂"],
|
|
"arrows": ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
|
|
"pulse": ["○", "◔", "◑", "◕", "●", "◕", "◑", "◔"],
|
|
}
|
|
chars = frames.get(style, frames["dots"])
|
|
start = time.time()
|
|
i = 0
|
|
while time.time() - start < duration:
|
|
frame = chars[i % len(chars)]
|
|
sys.stdout.write(f"\r {CYAN}{frame}{RESET} {GRAY}{text}{RESET} ")
|
|
sys.stdout.flush()
|
|
time.sleep(0.08)
|
|
i += 1
|
|
sys.stdout.write(f"\r {GREEN}✓{RESET} {GRAY}{text}{RESET} \n")
|
|
sys.stdout.flush()
|
|
|
|
|
|
def startup_sequence(root_path):
|
|
animate_logo()
|
|
loading_animation("Initializing analyzer", 0.3, "dots")
|
|
loading_animation("Loading language definitions", 0.2, "pulse")
|
|
loading_animation(f"Target: {root_path}", 0.2, "arrows")
|
|
print()
|
|
width = min(60, get_term_width() - 4)
|
|
print_centered("─" * width, DARKGRAY)
|
|
print()
|
|
|
|
|
|
def scan_progress(current, total, filename, width=40):
|
|
pct = (current / total * 100) if total else 0
|
|
filled = int(width * current / total) if total else 0
|
|
spinners = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
|
|
spinner = spinners[current % len(spinners)]
|
|
if pct < 25:
|
|
bar_color = CYAN
|
|
elif pct < 50:
|
|
bar_color = BLUE
|
|
elif pct < 75:
|
|
bar_color = TEAL
|
|
else:
|
|
bar_color = GREEN
|
|
bar_str = f"{bar_color}{'━' * filled}{DARKGRAY}{'─' * (width - filled)}{RESET}"
|
|
line1 = f" {CYAN}{spinner}{RESET} {bar_str} {GOLD}{pct:5.1f}%{RESET} {DARKGRAY}│{RESET} {GRAY}{current:,}/{total:,}{RESET}"
|
|
ext = Path(filename).suffix.lower()
|
|
icon = "📄"
|
|
if ext in CODE_LANGUAGES: icon = "💻"
|
|
elif ext in CONFIG_LANGUAGES: icon = "⚙️"
|
|
elif ext in DOC_LANGUAGES: icon = "📝"
|
|
max_fn = get_term_width() - 10
|
|
if len(filename) > max_fn:
|
|
filename = "..." + filename[-(max_fn - 3):]
|
|
line2 = f" {icon} {GRAY}{filename}{RESET}"
|
|
sys.stdout.write(f"\033[2A\033[2K{line1}\n\033[2K{line2}\n")
|
|
sys.stdout.flush()
|
|
|
|
|
|
def clear_scan_progress():
|
|
sys.stdout.write("\033[2A\033[2K\033[2K")
|
|
sys.stdout.write(f" {GREEN}✓{RESET} {GRAY}Scan complete{RESET}\n\n")
|
|
sys.stdout.flush()
|
|
|
|
|
|
# --------------------------------------------------
|
|
# Helpers / Metrics
|
|
# --------------------------------------------------
|
|
|
|
def horizontal_bar(percentage, width=24, color=None, bg_color=None):
|
|
filled = int(width * percentage / 100)
|
|
bar_filled = "█" * filled
|
|
bar_empty = "░" * (width - filled)
|
|
if color:
|
|
return f"{color}{bar_filled}{RESET}{DIM}{bar_empty}{RESET}"
|
|
return bar_filled + bar_empty
|
|
|
|
|
|
def format_number_short(n):
|
|
"""Format large numbers with K/M/B suffixes."""
|
|
if n >= 1_000_000_000:
|
|
return f"{n / 1_000_000_000:.1f}B"
|
|
if n >= 1_000_000:
|
|
return f"{n / 1_000_000:.1f}M"
|
|
if n >= 1_000:
|
|
return f"{n / 1_000:.1f}K"
|
|
return str(n)
|
|
|
|
|
|
def should_ignore_file(path: Path, root: Path, ignore_patterns=IGNORE_FILE_PATTERNS, ignore_globs=None, negation_globs=None):
|
|
"""Return True if file should be ignored based on name patterns or glob patterns.
|
|
|
|
- ignore_patterns: simple substrings (legacy behavior)
|
|
- ignore_globs: list of glob patterns relative to root (supports wildcards and paths)
|
|
- negation_globs: list of patterns that un-ignore files (overrides ignore_globs)
|
|
"""
|
|
name = path.name
|
|
|
|
# Calculate relative path for pattern matching
|
|
try:
|
|
rel = str(path.relative_to(root)).replace('\\', '/')
|
|
except ValueError:
|
|
# If can't get relative path, try resolved
|
|
try:
|
|
rel = str(path.resolve().relative_to(root.resolve())).replace('\\', '/')
|
|
except ValueError:
|
|
return True # Can't determine path, ignore it
|
|
|
|
# Check if file matches a negation pattern (should NOT be ignored)
|
|
if negation_globs:
|
|
for pat in negation_globs:
|
|
if fnmatch.fnmatch(rel, pat) or fnmatch.fnmatch(name, pat):
|
|
return False # Explicitly un-ignored
|
|
|
|
# Check simple substring patterns
|
|
if any(pattern in name for pattern in ignore_patterns):
|
|
return True
|
|
|
|
# Check glob patterns
|
|
if ignore_globs:
|
|
for pat in ignore_globs:
|
|
# try match against relative path and filename
|
|
if fnmatch.fnmatch(rel, pat) or fnmatch.fnmatch(name, pat):
|
|
return True
|
|
return False
|
|
|
|
|
|
_ALL_LANGUAGES = {}
|
|
_ALL_LANGUAGES.update(CODE_LANGUAGES)
|
|
_ALL_LANGUAGES.update(CONFIG_LANGUAGES)
|
|
_ALL_LANGUAGES.update(DOC_LANGUAGES)
|
|
|
|
def detect_language(extension):
|
|
return _ALL_LANGUAGES.get(extension)
|
|
|
|
|
|
# --------------------------------------------------
|
|
# Pre-compiled regex patterns (module-level for performance)
|
|
# --------------------------------------------------
|
|
_RE_PY_FUNC = re.compile(r"^\s*(async\s+def|def)\s+\w+")
|
|
_RE_PY_CLASS = re.compile(r"^\s*class\s+\w+")
|
|
_RE_JS_FUNC = re.compile(r"\bfunction\b|=>")
|
|
_RE_JS_CLASS = re.compile(r"^\s*(export\s+)?(default\s+)?(abstract\s+)?class\s+\w+")
|
|
_RE_C_FAMILY = re.compile(r"^\s*(?:public|private|protected|static|final|abstract|async|override)?\s*(?:void|int|double|float|bool|String|var|dynamic|Future|Stream|List|Map|Set|[A-Z]\w*(?:<[^>]+>)?)?\s+\w+\s*\([^)]*\)\s*(?:async)?\s*[{:]?")
|
|
_RE_DART_FUNC = re.compile(r"^\s*(?:Future|Stream|void|bool|int|double|String|dynamic|var|[A-Z]\w*(?:<[^>]+>)?)\s+\w+\s*\(")
|
|
_RE_JAVA_METHOD = re.compile(r"^\s*(?:@\w+\s*)*(?:public|private|protected)?\s*(?:static)?\s*(?:final)?\s*(?:void|int|long|float|double|boolean|char|byte|short|String|[A-Z]\w*(?:<[^>]+>)?)\s+\w+\s*\(")
|
|
_RE_SWIFT_FUNC = re.compile(r"^\s*(?:@\w+\s*)*(?:public|private|internal|fileprivate|open)?\s*(?:static|class)?\s*func\s+\w+")
|
|
_RE_GO_FUNC = re.compile(r"^\s*func\s+(?:\([^)]+\)\s*)?\w+\s*\(")
|
|
_RE_RUST_FUNC = re.compile(r"^\s*(?:pub\s+)?(?:async\s+)?fn\s+\w+")
|
|
_RE_RUBY_DEF = re.compile(r"^\s*def\s+\w+")
|
|
_RE_RUBY_CLASS = re.compile(r"^\s*(class|module)\s+\w+")
|
|
_RE_TODO = re.compile(r"\b(TODO|FIXME)\b", re.IGNORECASE)
|
|
_RE_GENERAL_CLASS = re.compile(r"^\s*(?:export\s+)?(?:abstract\s+)?(?:public|private|protected|internal|open|sealed|data|final)?\s*(?:abstract\s+)?(?:class|struct|enum|interface|mixin|extension|typedef|protocol|trait)\s+\w+")
|
|
_RE_RUST_CLASS = re.compile(r"^\s*(?:pub\s+)?(?:struct|enum|trait|impl)\s+\w+")
|
|
_RE_GO_CLASS = re.compile(r"^\s*type\s+\w+\s+(?:struct|interface)\b")
|
|
_RE_ELIXIR_FUNC = re.compile(r"^\s*(def|defp|defmacro|defmacrop)\s+\w+")
|
|
_RE_ELIXIR_CLASS = re.compile(r"^\s*defmodule\s+\w+")
|
|
_RE_ERLANG_FUNC = re.compile(r"^[a-z]\w*\s*\(")
|
|
_RE_HASKELL_FUNC = re.compile(r"^[a-z]\w*\s+::")
|
|
_RE_HASKELL_DATA = re.compile(r"^\s*(data|newtype|class|type)\s+[A-Z]")
|
|
_RE_PERL_FUNC = re.compile(r"^\s*sub\s+\w+")
|
|
_RE_PERL_CLASS = re.compile(r"^\s*package\s+\w+")
|
|
_RE_LUA_FUNC = re.compile(r"(^\s*(local\s+)?function\s+\w+|=\s*function\s*\()")
|
|
_RE_PS_FUNC = re.compile(r"^\s*function\s+\w+", re.IGNORECASE)
|
|
_RE_PS_CLASS = re.compile(r"^\s*class\s+\w+", re.IGNORECASE)
|
|
_RE_SOLIDITY_FUNC = re.compile(r"^\s*(function|modifier|constructor|receive|fallback)\s+\w*")
|
|
_RE_SOLIDITY_CLASS = re.compile(r"^\s*(contract|library|interface)\s+\w+")
|
|
_RE_LISP_FUNC = re.compile(r"^\s*\(def(n|un|macro|multi|method|record|type|protocol)\s+")
|
|
_RE_LISP_IMPORT = re.compile(r"^\s*\((?:require|import|use|ns)\s+")
|
|
|
|
# Import patterns
|
|
_RE_IMPORT_PY = re.compile(r"^\s*(import|from)\s+")
|
|
_RE_IMPORT_JS = re.compile(r"^\s*(import\s+|const\s+.*=\s*require\(|require\()")
|
|
_RE_IMPORT_DART = re.compile(r"^\s*import\s+['\"]")
|
|
_RE_IMPORT_JAVA = re.compile(r"^\s*import\s+")
|
|
_RE_IMPORT_GO = re.compile(r"^\s*import\s+")
|
|
_RE_IMPORT_RUST = re.compile(r"^\s*(use|extern\s+crate)\s+")
|
|
_RE_IMPORT_C = re.compile(r"^\s*#\s*include\s+")
|
|
_RE_IMPORT_RUBY = re.compile(r"^\s*(require|require_relative|load)\s+")
|
|
_RE_IMPORT_ELIXIR = re.compile(r"^\s*(import|use|alias|require)\s+")
|
|
_RE_IMPORT_HASKELL = re.compile(r"^\s*import\s+")
|
|
_RE_IMPORT_PERL = re.compile(r"^\s*(use|require)\s+")
|
|
_RE_IMPORT_LUA = re.compile(r"^\s*(require|dofile|loadfile)\s*[\(\"']")
|
|
_RE_IMPORT_PS = re.compile(r"^\s*(Import-Module|using\s+(module|namespace|assembly))\s+", re.IGNORECASE)
|
|
|
|
# Language family sets
|
|
_LANGS_JS = frozenset({"JavaScript", "JavaScript (JSX)", "JavaScript (ESM)", "JavaScript (CJS)",
|
|
"TypeScript", "TypeScript (TSX)", "Shell", "Bash", "Zsh", "Groovy", "Scala", "PHP",
|
|
"CoffeeScript", "Vue", "Svelte", "Astro"})
|
|
_LANGS_C_FAMILY = frozenset({"C", "C Header", "C++", "C++ Header", "C#", "Objective-C", "Objective-C++",
|
|
"Java", "Kotlin", "Kotlin Script", "Gradle", "CUDA", "CUDA Header", "D",
|
|
"Hack", "Apex", "Apex Trigger"})
|
|
_LANGS_C_INCLUDE = frozenset({"C", "C Header", "C++", "C++ Header", "Objective-C", "Objective-C++", "CUDA", "CUDA Header"})
|
|
_LANGS_DART = frozenset({"Dart"})
|
|
_LANGS_SWIFT = frozenset({"Swift"})
|
|
_LANGS_GO = frozenset({"Go"})
|
|
_LANGS_RUST = frozenset({"Rust"})
|
|
_LANGS_RUBY = frozenset({"Ruby"})
|
|
_LANGS_ELIXIR = frozenset({"Elixir", "Elixir Script"})
|
|
_LANGS_ERLANG = frozenset({"Erlang", "Erlang Header"})
|
|
_LANGS_HASKELL = frozenset({"Haskell", "Literate Haskell", "Elm", "PureScript"})
|
|
_LANGS_PERL = frozenset({"Perl", "Perl Test"})
|
|
_LANGS_LUA = frozenset({"Lua"})
|
|
_LANGS_PS = frozenset({"PowerShell", "PowerShell Module", "PowerShell Data"})
|
|
_LANGS_SOLIDITY = frozenset({"Solidity"})
|
|
_LANGS_LISP = frozenset({"Clojure", "ClojureScript", "Lisp", "Common Lisp", "Scheme", "Racket"})
|
|
_LANGS_PYTHON = frozenset({"Python", "Python Stub"})
|
|
|
|
# --------------------------------------------------
|
|
# Analysis
|
|
# --------------------------------------------------
|
|
|
|
def load_ignore_files(root: Path):
|
|
"""Load ignore patterns from .gitignore/.ignore and return a list of glob patterns, directory names to ignore, and negation patterns."""
|
|
root = Path(root)
|
|
globs = []
|
|
dir_names = set()
|
|
negation_globs = [] # patterns that start with ! (un-ignore)
|
|
negation_dirs = set() # directory negations
|
|
for fname in IGNORE_FILES_TO_CHECK:
|
|
fpath = root / fname
|
|
if not fpath.exists():
|
|
continue
|
|
try:
|
|
with fpath.open('r', encoding='utf-8', errors='ignore') as fh:
|
|
for line in fh:
|
|
line = line.strip()
|
|
if not line or line.startswith('#'):
|
|
continue
|
|
# handle negations (lines starting with !)
|
|
if line.startswith('!'):
|
|
pattern = line[1:] # remove the !
|
|
if pattern.endswith('/'):
|
|
negation_dirs.add(pattern.rstrip('/'))
|
|
else:
|
|
negation_globs.append(pattern)
|
|
continue
|
|
# directory pattern
|
|
if line.endswith('/'):
|
|
dir_names.add(line.rstrip('/'))
|
|
else:
|
|
globs.append(line)
|
|
except Exception:
|
|
continue
|
|
return list(globs), dir_names, list(negation_globs), negation_dirs
|
|
|
|
|
|
def analyze_file(path: Path):
|
|
info = detect_language(path.suffix.lower())
|
|
if not info:
|
|
# fallback for special filenames (Dockerfile, Dockerfile.*, Makefile) or shebang
|
|
name = path.name
|
|
if name in SPECIAL_FILES:
|
|
info = SPECIAL_FILES[name]
|
|
elif name.lower().startswith('dockerfile'):
|
|
# catch Dockerfile, Dockerfile.bot, Dockerfile.native, etc.
|
|
info = ('Dockerfile', '#', 'code')
|
|
else:
|
|
try:
|
|
with path.open('r', encoding='utf-8', errors='ignore') as fh:
|
|
first = fh.readline()
|
|
if first.startswith('#!'):
|
|
info = ('Shell', '#', 'code')
|
|
except Exception:
|
|
pass
|
|
|
|
if not info:
|
|
return None
|
|
|
|
language, comment_token, category = info
|
|
|
|
# Skip extremely large files (minified bundles, generated code, blobs)
|
|
try:
|
|
size = path.stat().st_size
|
|
except OSError:
|
|
return None
|
|
if size > 1_000_000: # 1MB cap — files above this are overwhelmingly minified/generated
|
|
# Still report the file but with minimal metadata (no line-by-line analysis)
|
|
return {
|
|
"path": str(path),
|
|
"relpath": str(path),
|
|
"language": language,
|
|
"category": category,
|
|
"code_lines": 0,
|
|
"code_chars": 0,
|
|
"comment_lines": 0,
|
|
"empty_lines": 0,
|
|
"total_lines": 0,
|
|
"size_bytes": size,
|
|
"function_count": 0,
|
|
"class_count": 0,
|
|
"todo_count": 0,
|
|
"longest_line": 0,
|
|
"avg_line_length": 0,
|
|
"avg_func_length": 0,
|
|
"max_nesting_depth": 0,
|
|
"long_lines": 0,
|
|
"import_count": 0,
|
|
"comment_ratio": 0,
|
|
"has_comment": bool(comment_token),
|
|
}
|
|
|
|
# Single-pass analysis: line counting + function/class/import detection
|
|
code = comments = empty = 0
|
|
code_chars = 0
|
|
func_count = class_count = todo_count = 0
|
|
longest_line = 0
|
|
avg_len_acc = 0
|
|
max_nesting = 0
|
|
current_nesting = 0
|
|
long_lines = 0
|
|
import_count = 0
|
|
total_lines = 0
|
|
|
|
# Select the right import matcher for this language
|
|
import_matcher = None
|
|
if language in _LANGS_PYTHON:
|
|
import_matcher = _RE_IMPORT_PY
|
|
elif language in _LANGS_DART:
|
|
import_matcher = _RE_IMPORT_DART
|
|
elif language in _LANGS_JS:
|
|
import_matcher = _RE_IMPORT_JS
|
|
elif language in _LANGS_C_FAMILY:
|
|
import_matcher = _RE_IMPORT_C if language in _LANGS_C_INCLUDE else _RE_IMPORT_JAVA
|
|
elif language in _LANGS_GO:
|
|
import_matcher = _RE_IMPORT_GO
|
|
elif language in _LANGS_RUST:
|
|
import_matcher = _RE_IMPORT_RUST
|
|
elif language in _LANGS_RUBY:
|
|
import_matcher = _RE_IMPORT_RUBY
|
|
elif language in _LANGS_SWIFT:
|
|
import_matcher = _RE_IMPORT_JAVA
|
|
elif language in _LANGS_ELIXIR:
|
|
import_matcher = _RE_IMPORT_ELIXIR
|
|
elif language in _LANGS_HASKELL:
|
|
import_matcher = _RE_IMPORT_HASKELL
|
|
elif language in _LANGS_PERL:
|
|
import_matcher = _RE_IMPORT_PERL
|
|
elif language in _LANGS_LUA:
|
|
import_matcher = _RE_IMPORT_LUA
|
|
elif language in _LANGS_PS:
|
|
import_matcher = _RE_IMPORT_PS
|
|
elif language in _LANGS_LISP:
|
|
import_matcher = _RE_LISP_IMPORT
|
|
|
|
# Select the right func/class matchers for this language
|
|
func_matcher = class_matcher = None
|
|
func_is_search = False # use .search() instead of .match()
|
|
func_matcher2 = None # secondary func matcher (for dart/c-family)
|
|
if language in _LANGS_PYTHON:
|
|
func_matcher = _RE_PY_FUNC
|
|
class_matcher = _RE_PY_CLASS
|
|
elif language in _LANGS_JS:
|
|
func_matcher = _RE_JS_FUNC
|
|
func_is_search = True
|
|
class_matcher = _RE_JS_CLASS
|
|
elif language in _LANGS_DART:
|
|
func_matcher = _RE_DART_FUNC
|
|
func_matcher2 = _RE_C_FAMILY
|
|
class_matcher = _RE_GENERAL_CLASS
|
|
elif language in _LANGS_C_FAMILY:
|
|
func_matcher = _RE_JAVA_METHOD
|
|
func_matcher2 = _RE_C_FAMILY
|
|
class_matcher = _RE_GENERAL_CLASS
|
|
elif language in _LANGS_SWIFT:
|
|
func_matcher = _RE_SWIFT_FUNC
|
|
class_matcher = _RE_GENERAL_CLASS
|
|
elif language in _LANGS_GO:
|
|
func_matcher = _RE_GO_FUNC
|
|
class_matcher = _RE_GO_CLASS
|
|
elif language in _LANGS_RUST:
|
|
func_matcher = _RE_RUST_FUNC
|
|
class_matcher = _RE_RUST_CLASS
|
|
elif language in _LANGS_RUBY:
|
|
func_matcher = _RE_RUBY_DEF
|
|
class_matcher = _RE_RUBY_CLASS
|
|
elif language in _LANGS_ELIXIR:
|
|
func_matcher = _RE_ELIXIR_FUNC
|
|
class_matcher = _RE_ELIXIR_CLASS
|
|
elif language in _LANGS_ERLANG:
|
|
func_matcher = _RE_ERLANG_FUNC
|
|
elif language in _LANGS_HASKELL:
|
|
func_matcher = _RE_HASKELL_FUNC
|
|
class_matcher = _RE_HASKELL_DATA
|
|
elif language in _LANGS_PERL:
|
|
func_matcher = _RE_PERL_FUNC
|
|
class_matcher = _RE_PERL_CLASS
|
|
elif language in _LANGS_LUA:
|
|
func_matcher = _RE_LUA_FUNC
|
|
func_is_search = True
|
|
elif language in _LANGS_PS:
|
|
func_matcher = _RE_PS_FUNC
|
|
class_matcher = _RE_PS_CLASS
|
|
elif language in _LANGS_SOLIDITY:
|
|
func_matcher = _RE_SOLIDITY_FUNC
|
|
class_matcher = _RE_SOLIDITY_CLASS
|
|
elif language in _LANGS_LISP:
|
|
func_matcher = _RE_LISP_FUNC
|
|
else:
|
|
class_matcher = _RE_GENERAL_CLASS
|
|
|
|
_todo_search = _RE_TODO.search
|
|
_LINE_LEN_CAP = 10_000 # skip regex on very long lines (minified code)
|
|
_MAX_LINES = 100_000 # bail out on files with excessive line counts
|
|
|
|
try:
|
|
with path.open("r", encoding="utf-8", errors="ignore") as fh:
|
|
for line in fh:
|
|
total_lines += 1
|
|
if total_lines > _MAX_LINES:
|
|
break
|
|
stripped = line.strip()
|
|
|
|
# Line counting (code / comment / empty)
|
|
if not stripped:
|
|
empty += 1
|
|
elif comment_token and stripped.startswith(comment_token):
|
|
comments += 1
|
|
else:
|
|
code += 1
|
|
code_chars += len(stripped)
|
|
|
|
# Line length metrics
|
|
l_len = len(line) - 1 if line.endswith('\n') else len(line)
|
|
avg_len_acc += l_len
|
|
if l_len > longest_line:
|
|
longest_line = l_len
|
|
if l_len > 120:
|
|
long_lines += 1
|
|
|
|
# Skip regex analysis on extremely long lines (minified code)
|
|
if l_len > _LINE_LEN_CAP:
|
|
continue
|
|
|
|
# Nesting depth (brace-based)
|
|
if stripped and not stripped.startswith(('//', '#', '/*', '*', '<!--')):
|
|
delta = (stripped.count('{') + stripped.count('(')) - (stripped.count('}') + stripped.count(')'))
|
|
current_nesting += delta
|
|
if current_nesting < 0:
|
|
current_nesting = 0
|
|
if current_nesting > max_nesting:
|
|
max_nesting = current_nesting
|
|
|
|
# TODO/FIXME detection
|
|
if _todo_search(line):
|
|
todo_count += 1
|
|
|
|
# Import detection
|
|
if import_matcher and import_matcher.match(line):
|
|
import_count += 1
|
|
|
|
# Function/class detection
|
|
if class_matcher and class_matcher.match(line):
|
|
class_count += 1
|
|
elif func_matcher:
|
|
if func_is_search:
|
|
if func_matcher.search(line):
|
|
func_count += 1
|
|
else:
|
|
if func_matcher.match(line):
|
|
func_count += 1
|
|
elif func_matcher2 and func_matcher2.match(line):
|
|
func_count += 1
|
|
except Exception:
|
|
return None
|
|
|
|
avg_line_len = (avg_len_acc / total_lines) if total_lines else 0.0
|
|
total = code + comments + empty
|
|
comment_ratio = (comments / code * 100) if code else 0
|
|
avg_func_length = (code / func_count) if func_count else 0
|
|
|
|
return {
|
|
"path": str(path),
|
|
"relpath": str(path),
|
|
"language": language,
|
|
"category": category,
|
|
"code_lines": code,
|
|
"code_chars": code_chars,
|
|
"comment_lines": comments,
|
|
"empty_lines": empty,
|
|
"total_lines": total,
|
|
"size_bytes": size,
|
|
"function_count": func_count,
|
|
"class_count": class_count,
|
|
"todo_count": todo_count,
|
|
"longest_line": longest_line,
|
|
"avg_line_length": avg_line_len,
|
|
"avg_func_length": avg_func_length,
|
|
"max_nesting_depth": max_nesting,
|
|
"long_lines": long_lines,
|
|
"import_count": import_count,
|
|
"comment_ratio": comment_ratio,
|
|
"has_comment": bool(comment_token),
|
|
}
|
|
|
|
|
|
def get_git_info(root: Path, commit_msg_max: int = 120):
|
|
"""Return git info dict if 'root' is inside a git worktree, otherwise None.
|
|
|
|
commit_msg_max: max characters for the single-line commit message shown (truncated).
|
|
"""
|
|
try:
|
|
p = subprocess.run(["git", "rev-parse", "--is-inside-work-tree"], cwd=str(root), capture_output=True, text=True)
|
|
if p.returncode != 0 or p.stdout.strip() != "true":
|
|
return None
|
|
|
|
branch = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=str(root), capture_output=True, text=True).stdout.strip()
|
|
|
|
commit_out = subprocess.run(["git", "log", "-1", "--pretty=format:%h;%an;%ad;%B", "--date=short"], cwd=str(root), capture_output=True, text=True)
|
|
latest = None
|
|
if commit_out.returncode == 0 and commit_out.stdout:
|
|
# use %B for full raw body, then split fields manually
|
|
raw = commit_out.stdout.strip()
|
|
# the format we used here is: <hash>;<author>;<date>;<body...>
|
|
parts = raw.split(";", 3)
|
|
if len(parts) == 4:
|
|
short, author, date, msg = parts
|
|
# collapse multi-line messages to single line and trim
|
|
single = " ".join(line.strip() for line in msg.splitlines()).strip()
|
|
if len(single) > commit_msg_max:
|
|
short_msg = single[:commit_msg_max - 1].rstrip() + "…"
|
|
else:
|
|
short_msg = single
|
|
latest = {"hash": short, "author": author, "date": date, "message": msg, "message_short": short_msg}
|
|
|
|
# commit count
|
|
commit_count = 0
|
|
ccount = subprocess.run(["git", "rev-list", "--count", "HEAD"], cwd=str(root), capture_output=True, text=True)
|
|
if ccount.returncode == 0 and ccount.stdout.strip().isdigit():
|
|
commit_count = int(ccount.stdout.strip())
|
|
|
|
# files changed in last commit
|
|
files_changed = []
|
|
files_out = subprocess.run(["git", "diff-tree", "--no-commit-id", "--name-only", "-r", "HEAD"], cwd=str(root), capture_output=True, text=True)
|
|
if files_out.returncode == 0 and files_out.stdout:
|
|
files_changed = [l for l in files_out.stdout.splitlines() if l.strip()]
|
|
|
|
# stats (insertions/deletions) for last commit
|
|
insertions = deletions = 0
|
|
stats_out = subprocess.run(["git", "show", "--numstat", "-1", "HEAD"], cwd=str(root), capture_output=True, text=True)
|
|
if stats_out.returncode == 0 and stats_out.stdout:
|
|
for line in stats_out.stdout.splitlines():
|
|
parts = line.split()
|
|
if len(parts) >= 3:
|
|
try:
|
|
ins = int(parts[0]) if parts[0].isdigit() else 0
|
|
dels = int(parts[1]) if parts[1].isdigit() else 0
|
|
insertions += ins
|
|
deletions += dels
|
|
except Exception:
|
|
pass
|
|
|
|
# remote URL
|
|
remote = subprocess.run(["git", "config", "--get", "remote.origin.url"], cwd=str(root), capture_output=True, text=True)
|
|
remote_url = remote.stdout.strip() if remote.returncode == 0 and remote.stdout else None
|
|
|
|
status_out = subprocess.run(["git", "status", "--porcelain"], cwd=str(root), capture_output=True, text=True)
|
|
changed = untracked = 0
|
|
dirty = False
|
|
if status_out.returncode == 0:
|
|
lines = [l for l in status_out.stdout.splitlines() if l.strip()]
|
|
changed = sum(1 for l in lines if not l.startswith("??"))
|
|
untracked = sum(1 for l in lines if l.startswith("??"))
|
|
dirty = bool(lines)
|
|
|
|
ahead = behind = 0
|
|
ub = subprocess.run(["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd=str(root), capture_output=True, text=True)
|
|
if ub.returncode == 0:
|
|
upstream = ub.stdout.strip()
|
|
ab = subprocess.run(["git", "rev-list", "--left-right", "--count", f"{upstream}...HEAD"], cwd=str(root), capture_output=True, text=True)
|
|
if ab.returncode == 0 and ab.stdout:
|
|
behind_s, ahead_s = ab.stdout.strip().split()
|
|
behind = int(behind_s)
|
|
ahead = int(ahead_s)
|
|
|
|
return {
|
|
"branch": branch,
|
|
"dirty": dirty,
|
|
"changed": changed,
|
|
"untracked": untracked,
|
|
"ahead": ahead,
|
|
"behind": behind,
|
|
"latest_commit": latest,
|
|
"commit_count": commit_count,
|
|
"last_files_changed": files_changed,
|
|
"last_commit_insertions": insertions,
|
|
"last_commit_deletions": deletions,
|
|
"remote_url": remote_url,
|
|
}
|
|
except Exception:
|
|
return None
|
|
|
|
# --------------------------------------------------
|
|
# CLI
|
|
# --------------------------------------------------
|
|
|
|
SPECIAL_FILES = {
|
|
'Dockerfile': ("Dockerfile", "#", "code"),
|
|
'Makefile': ("Makefile", "#", "code"),
|
|
}
|
|
|
|
|
|
def parse_args():
|
|
p = argparse.ArgumentParser(description="pjstats -- enhanced project stats", epilog=HELP_TEXT, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
p.add_argument("path", nargs="?", default='.', help="Project root path")
|
|
p.add_argument("--json", action="store_true", help="Output JSON summary")
|
|
p.add_argument("--top", type=int, default=5, help="Top N files to display")
|
|
p.add_argument("--ext", nargs="*", help="Limit to specific extensions (e.g. .py .js)")
|
|
p.add_argument("--min-code-lines", type=int, default=0, help="Ignore files with fewer code lines than this")
|
|
p.add_argument("--exclude", nargs="*", default=[], help="Directories to ignore recursively (relative to project root)")
|
|
p.add_argument("--include-hidden", action="store_true", help="Include hidden directories/files")
|
|
p.add_argument("--no-color", action="store_true", help="Disable color output")
|
|
p.add_argument("--no-git", action="store_true", help="Disable Git info detection")
|
|
p.add_argument("--no-animation", action="store_true", help="Disable startup animation and progress bars")
|
|
p.add_argument("--bypass-excluded", action="store_true", help="Bypass all ignore rules (.gitignore, built-in excludes, hidden dirs, etc.) and scan everything")
|
|
p.add_argument("--workers", type=int, default=0, help="Number of threads for parallel analysis (0=auto)")
|
|
p.add_argument("--commit-msg-max", type=int, default=120, help="Max characters to show for commit message (single-line, truncated)")
|
|
p.add_argument("--install", action="store_true", help="Install pjstats to a directory in your PATH (auto-detected per OS if not provided)")
|
|
p.add_argument("--uninstall", action="store_true", help="Remove installed pjstats from install directory")
|
|
p.add_argument("--install-dir", default=None, help="Installation directory (auto-detected per OS if not set)")
|
|
return p.parse_args()
|
|
|
|
|
|
def default_install_dir():
|
|
"""Return a sensible default install directory depending on the OS."""
|
|
system = platform.system()
|
|
if system == 'Windows':
|
|
# prefer %LOCALAPPDATA%/Programs/pjstats, fallback to %USERPROFILE%/Scripts
|
|
local = os.environ.get('LOCALAPPDATA')
|
|
if local:
|
|
return str(Path(local) / 'Programs' / 'pjstats')
|
|
up = os.environ.get('USERPROFILE')
|
|
if up:
|
|
return str(Path(up) / 'Scripts')
|
|
return str(Path.home() / 'Scripts')
|
|
else:
|
|
# Unix-like default
|
|
return str(Path.home() / '.local' / 'bin')
|
|
|
|
|
|
def install_self(install_dir: str):
|
|
install_dir = Path(os.path.expanduser(install_dir))
|
|
install_dir.mkdir(parents=True, exist_ok=True)
|
|
src = Path(__file__).resolve()
|
|
dest = install_dir / 'pjstats'
|
|
try:
|
|
# normalize line endings while installing to avoid CRLF shebang issues
|
|
with src.open('r', encoding='utf-8', errors='ignore') as fh:
|
|
text = fh.read()
|
|
with dest.open('w', encoding='utf-8', newline='\n') as fh:
|
|
fh.write(text.replace('\r\n', '\n').replace('\r', '\n'))
|
|
dest.chmod(0o755)
|
|
print(f"Installed pjstats -> {dest}")
|
|
# warn if install_dir not in PATH
|
|
path_env = os.environ.get('PATH','')
|
|
if str(install_dir) not in path_env.split(os.pathsep):
|
|
if platform.system() == 'Windows':
|
|
print(f"Note: {install_dir} is not in your PATH. Consider adding it to your User PATH or copy to a directory already on PATH.")
|
|
else:
|
|
print(f"Note: {install_dir} is not in your PATH. Add it to your PATH (e.g. export PATH=\"{install_dir}:$PATH\") to use 'pjstats' directly.")
|
|
return True
|
|
except Exception as exc:
|
|
print(f"Failed to install: {exc}")
|
|
return False
|
|
|
|
|
|
def uninstall_self(install_dir: str):
|
|
install_dir = Path(os.path.expanduser(install_dir))
|
|
dest = install_dir / 'pjstats'
|
|
try:
|
|
if dest.exists():
|
|
dest.unlink()
|
|
print(f"Removed {dest}")
|
|
return True
|
|
else:
|
|
print(f"pjstats is not installed at {dest}")
|
|
return False
|
|
except Exception as exc:
|
|
print(f"Failed to uninstall: {exc}")
|
|
return False
|
|
|
|
|
|
def compute_quality_score(data):
|
|
"""Compute a 0-100 quality score using smooth curves for realistic assessment.
|
|
|
|
Uses continuous penalties proportional to how far each metric deviates
|
|
from ideal values, rather than hard step thresholds.
|
|
"""
|
|
score = 100.0
|
|
|
|
# 1. Comment ratio (max -30 pts) - smooth curve with over-commenting penalty
|
|
if data.get('has_comment', True) and data['code_lines'] > 0:
|
|
cr = data['comment_lines'] / data['code_lines'] * 100
|
|
if cr < 1:
|
|
score -= 30
|
|
elif cr < 5:
|
|
# 30 -> 18 as cr goes 0 -> 5
|
|
score -= 30 - (cr / 5) * 12
|
|
elif cr < 10:
|
|
# 18 -> 8 as cr goes 5 -> 10
|
|
score -= 18 - ((cr - 5) / 5) * 10
|
|
elif cr < 20:
|
|
# 8 -> 0 as cr goes 10 -> 20
|
|
score -= 8 - ((cr - 10) / 10) * 8
|
|
# Penalty for excessive commenting (>60% is unusual)
|
|
if cr > 60:
|
|
score -= min(10, (cr - 60) / 10 * 5)
|
|
|
|
# 2. Lines per function (max -20 pts) - smooth curve
|
|
if data['function_count'] > 0:
|
|
lpf = data['code_lines'] / data['function_count']
|
|
if lpf > 100:
|
|
score -= 20
|
|
elif lpf > 60:
|
|
score -= 10 + (lpf - 60) / 40 * 10
|
|
elif lpf > 30:
|
|
score -= (lpf - 30) / 30 * 10
|
|
# Too many tiny functions penalty (< 3 lines avg with many funcs)
|
|
if lpf < 3 and data['function_count'] > 5:
|
|
score -= 5
|
|
|
|
# 3. TODO/FIXME density per 1000 lines (max -10 pts) - proportional
|
|
td = data.get('todo_density', 0)
|
|
if td > 0:
|
|
score -= min(10, td * 0.5)
|
|
|
|
# 4. Max nesting depth (max -15 pts) - smooth from depth 3+
|
|
mnd = data.get('max_nesting_depth', 0)
|
|
if mnd > 3:
|
|
score -= min(15, (mnd - 3) * 2.5)
|
|
|
|
# 5. Long line ratio (max -10 pts) - proportional
|
|
llr = data.get('long_line_ratio', 0)
|
|
if llr > 0:
|
|
score -= min(10, llr * 0.7)
|
|
|
|
# 6. Large file count (max -10 pts) - proportional to % of files > 300 lines
|
|
if data['files'] > 0:
|
|
lf_pct = data.get('large_file_count', 0) / data['files'] * 100
|
|
if lf_pct > 0:
|
|
score -= min(10, lf_pct * 0.2)
|
|
|
|
# 7. File size consistency (max -5 pts) - coefficient of variation
|
|
med = data.get('median_code_lines', 0)
|
|
sd = data.get('stddev_code_lines', 0)
|
|
if med > 0:
|
|
cv = sd / med
|
|
if cv > 0.5:
|
|
score -= min(5, (cv - 0.5) * 3.3)
|
|
|
|
return max(0, min(100, round(score, 1)))
|
|
|
|
|
|
def score_color(score, no_color=False):
|
|
"""Return an ANSI color for a quality score."""
|
|
if no_color:
|
|
return ""
|
|
if score >= 80:
|
|
return GREEN
|
|
elif score >= 60:
|
|
return YELLOW
|
|
elif score >= 40:
|
|
return ORANGE
|
|
else:
|
|
return RED
|
|
|
|
|
|
def score_grade(score):
|
|
"""Return a letter grade for a quality score."""
|
|
if score >= 90:
|
|
return "A+"
|
|
elif score >= 85:
|
|
return "A"
|
|
elif score >= 80:
|
|
return "A-"
|
|
elif score >= 75:
|
|
return "B+"
|
|
elif score >= 70:
|
|
return "B"
|
|
elif score >= 65:
|
|
return "B-"
|
|
elif score >= 60:
|
|
return "C+"
|
|
elif score >= 55:
|
|
return "C"
|
|
elif score >= 50:
|
|
return "C-"
|
|
elif score >= 45:
|
|
return "D+"
|
|
elif score >= 40:
|
|
return "D"
|
|
else:
|
|
return "F"
|
|
|
|
|
|
def print_summary(result, root: Path, args):
|
|
if args.no_color:
|
|
global BOLD, DIM, BLUE, GREEN, ORANGE, RED, RESET, CYAN, MAGENTA, YELLOW, WHITE, PURPLE, PINK, TEAL
|
|
BOLD = DIM = BLUE = GREEN = ORANGE = RED = RESET = CYAN = MAGENTA = YELLOW = WHITE = PURPLE = PINK = TEAL = ""
|
|
|
|
language_stats = result["language_stats"]
|
|
category_totals = result["category_totals"]
|
|
per_file = result["per_file"]
|
|
|
|
total_files = len(per_file)
|
|
total_lines = sum(f["total_lines"] for f in per_file)
|
|
|
|
print(f"\n{BOLD}{CYAN}PROJECT OVERVIEW{RESET}")
|
|
print(f"{DIM}{root}{RESET}\n")
|
|
if not args.no_git:
|
|
git = get_git_info(root, args.commit_msg_max)
|
|
if git:
|
|
s = f"{PURPLE}Git:{RESET} branch {YELLOW}{git['branch']}{RESET}"
|
|
if git.get('dirty'):
|
|
s += f" | {ORANGE}modified:{git.get('changed',0)}{RESET} {DIM}untracked:{git.get('untracked',0)}{RESET}"
|
|
if git.get('ahead') or git.get('behind'):
|
|
ahead_c = GREEN if git.get('ahead', 0) > 0 else DIM
|
|
behind_c = RED if git.get('behind', 0) > 0 else DIM
|
|
s += f" | {ahead_c}ahead:{git.get('ahead',0)}{RESET} {behind_c}behind:{git.get('behind',0)}{RESET}"
|
|
if git.get('commit_count'):
|
|
s += f" | {CYAN}commits:{git.get('commit_count')}{RESET}"
|
|
cm = git.get('latest_commit') or {}
|
|
if cm:
|
|
s += f" | latest {MAGENTA}{cm.get('hash')}{RESET} by {BLUE}{cm.get('author')}{RESET} on {DIM}{cm.get('date')}{RESET}"
|
|
|
|
# insertion/deletion summary for last commit
|
|
ins = git.get('last_commit_insertions', 0) or 0
|
|
dels = git.get('last_commit_deletions', 0) or 0
|
|
files_changed = git.get('last_files_changed') or []
|
|
if files_changed:
|
|
s += f" | last {GREEN}+{ins}{RESET}/{RED}-{dels}{RESET} in {WHITE}{len(files_changed)}{RESET} files"
|
|
print(s)
|
|
|
|
# show the commit message on its own (single-line, truncated)
|
|
if cm and cm.get('message_short'):
|
|
print(f" {DIM}Message:{RESET} {cm.get('message_short')}")
|
|
|
|
# print a concise list of files changed in the last commit (first 6)
|
|
if files_changed:
|
|
show = files_changed[:6]
|
|
more = len(files_changed) - len(show)
|
|
files_line = f"{DIM}, {RESET}".join(f"{TEAL}{f}{RESET}" for f in show)
|
|
if more > 0:
|
|
files_line += f" {DIM}(+{more} more){RESET}"
|
|
print(f" {DIM}Changed files:{RESET} {files_line}")
|
|
|
|
total_chars = sum(f.get("code_chars", 0) for f in per_file)
|
|
total_funcs = sum(f.get("function_count", 0) for f in per_file)
|
|
total_classes = sum(f.get("class_count", 0) for f in per_file)
|
|
total_todos = sum(f.get("todo_count", 0) for f in per_file)
|
|
print(f"{DIM}Files scanned :{RESET} {CYAN}{total_files}{RESET}")
|
|
print(f"{DIM}Total lines :{RESET} {CYAN}{total_lines:,}{RESET}")
|
|
print(f"{DIM}Total characters (code) :{RESET} {CYAN}{total_chars:,}{RESET}")
|
|
print(f"{DIM}Functions / Methods :{RESET} {MAGENTA}{total_funcs:,}{RESET}")
|
|
print(f"{DIM}Classes / Structs :{RESET} {PURPLE}{total_classes:,}{RESET}")
|
|
print(f"{DIM}TODO / FIXME markers :{RESET} {ORANGE}{total_todos:,}{RESET}")
|
|
print()
|
|
|
|
# Category colors
|
|
cat_colors = {"code": BLUE, "config": ORANGE, "docs": MAGENTA}
|
|
|
|
print(f"{BOLD}{CYAN}CONTENT DISTRIBUTION{RESET}")
|
|
for category, lines in category_totals.items():
|
|
percent = (lines / total_lines * 100) if total_lines else 0
|
|
label = category.capitalize()
|
|
cat_color = cat_colors.get(category, WHITE)
|
|
print(
|
|
f"{cat_color}{label:<15}{RESET} "
|
|
f"{WHITE}{lines:>8,}{RESET} {DIM}lines{RESET} "
|
|
f"{YELLOW}{percent:>5.1f}%{RESET} "
|
|
f"{horizontal_bar(percent, color=cat_color)}"
|
|
)
|
|
|
|
print(f"\n{BOLD}{CYAN}LANGUAGE IMPACT (actual code){RESET}")
|
|
code_total = sum(v["code_lines"] for v in language_stats.values())
|
|
chars_total = sum(v["code_chars"] for v in language_stats.values())
|
|
|
|
# Color mapping for language groups
|
|
def get_lang_color(lang):
|
|
if "Python" in lang or "Mojo" in lang: return YELLOW
|
|
if "Dart" in lang or "Flutter" in lang: return TEAL
|
|
if "Java" in lang or "Kotlin" in lang or "Gradle" in lang: return ORANGE
|
|
if "JavaScript" in lang or "TypeScript" in lang or "CoffeeScript" in lang: return YELLOW
|
|
if "Swift" in lang: return ORANGE
|
|
if "C++" in lang or "C#" in lang or lang == "C" or "Header" in lang or "CUDA" in lang: return BLUE
|
|
if "Objective" in lang: return BLUE
|
|
if "Markdown" in lang or lang in ("reStructuredText", "AsciiDoc", "LaTeX", "Org Mode"): return MAGENTA
|
|
if "SQL" in lang: return CYAN
|
|
if "Shell" in lang or "Bash" in lang or "Zsh" in lang or "Fish" in lang or "KornShell" in lang: return GREEN
|
|
if "PowerShell" in lang or "Batch" in lang: return GREEN
|
|
if "Rust" in lang: return RED
|
|
if "Go" in lang or lang == "V" or "Zig" in lang or "Odin" in lang: return CYAN
|
|
if "Ruby" in lang or "Crystal" in lang: return RED
|
|
if "Elixir" in lang or "Erlang" in lang: return PURPLE
|
|
if "Haskell" in lang or "Elm" in lang or "PureScript" in lang or "OCaml" in lang: return PURPLE
|
|
if "Clojure" in lang or "Lisp" in lang or "Scheme" in lang or "Racket" in lang: return PURPLE
|
|
if "Lua" in lang: return BLUE
|
|
if "PHP" in lang: return PURPLE
|
|
if "Perl" in lang: return PINK
|
|
if "Scala" in lang or "Groovy" in lang: return RED
|
|
if "F#" in lang: return BLUE
|
|
if "Nim" in lang or "Julia" in lang: return PURPLE
|
|
if "Solidity" in lang: return ORANGE
|
|
if "Terraform" in lang or "HCL" in lang: return PURPLE
|
|
if "Vue" in lang or "Svelte" in lang or "Astro" in lang: return GREEN
|
|
if "Fortran" in lang or "COBOL" in lang or "Pascal" in lang or "Ada" in lang: return BLUE
|
|
if "Assembly" in lang or "VHDL" in lang or "SystemVerilog" in lang: return BLUE
|
|
if "Protobuf" in lang or "Thrift" in lang or "GraphQL" in lang: return CYAN
|
|
if lang in ("D", "Hack", "Gleam", "Wren", "Dhall"): return TEAL
|
|
if "ReScript" in lang or "Reason" in lang: return RED
|
|
if "VB" in lang: return BLUE
|
|
if "Nix" in lang or "Starlark" in lang or "Jsonnet" in lang: return CYAN
|
|
return WHITE
|
|
|
|
for language, data in sorted(language_stats.items(), key=lambda x: x[1]["code_lines"], reverse=True):
|
|
if data["code_lines"] == 0:
|
|
continue
|
|
percent = (data["code_lines"] / code_total * 100) if code_total else 0
|
|
lang_color = get_lang_color(language)
|
|
chars_str = format_number_short(data['code_chars'])
|
|
print(
|
|
f"{lang_color}{language:<18}{RESET} "
|
|
f"{WHITE}{data['code_lines']:>8,}{RESET} {DIM}lines{RESET} "
|
|
f"{PURPLE}{chars_str:>7}{RESET} {DIM}chars{RESET} "
|
|
f"{YELLOW}{percent:>5.1f}%{RESET} "
|
|
f"{horizontal_bar(percent, color=lang_color)}"
|
|
)
|
|
|
|
print(f"\n{BOLD}{CYAN}DECLARATIONS{RESET}")
|
|
# Sort by total declarations (functions + classes) descending
|
|
decl_items = [(lang, data) for lang, data in language_stats.items()
|
|
if (data.get('function_count', 0) + data.get('class_count', 0)) > 0]
|
|
decl_items.sort(key=lambda x: x[1].get('function_count', 0) + x[1].get('class_count', 0), reverse=True)
|
|
|
|
if decl_items:
|
|
# Dynamic column widths
|
|
dfunc_w = max(len(str(d.get('function_count', 0))) for _, d in decl_items)
|
|
dclass_w = max(len(str(d.get('class_count', 0))) for _, d in decl_items)
|
|
dtotal_w = max(len(str(d.get('function_count', 0) + d.get('class_count', 0))) for _, d in decl_items)
|
|
|
|
for language, data in decl_items:
|
|
funcs = data.get('function_count', 0)
|
|
classes = data.get('class_count', 0)
|
|
total_decl = funcs + classes
|
|
lang_color = get_lang_color(language)
|
|
print(
|
|
f"{lang_color}{language:<18}{RESET} "
|
|
f"{MAGENTA}{funcs:>{dfunc_w}}{RESET} {DIM}funcs{RESET} "
|
|
f"{PURPLE}{classes:>{dclass_w}}{RESET} {DIM}classes{RESET} "
|
|
f"{DIM}={RESET} "
|
|
f"{WHITE}{total_decl:>{dtotal_w}}{RESET} {DIM}total{RESET}"
|
|
)
|
|
|
|
# Totals row
|
|
sum_funcs = sum(d.get('function_count', 0) for _, d in decl_items)
|
|
sum_classes = sum(d.get('class_count', 0) for _, d in decl_items)
|
|
sum_total = sum_funcs + sum_classes
|
|
print(f"{DIM}{'─' * 18}{RESET} {DIM}{'─' * (dfunc_w + 6)} {'─' * (dclass_w + 8)} {'─' * 2} {'─' * (dtotal_w + 6)}{RESET}")
|
|
print(
|
|
f"{BOLD}{'Total':<18}{RESET} "
|
|
f"{MAGENTA}{sum_funcs:>{dfunc_w}}{RESET} {DIM}funcs{RESET} "
|
|
f"{PURPLE}{sum_classes:>{dclass_w}}{RESET} {DIM}classes{RESET} "
|
|
f"{DIM}={RESET} "
|
|
f"{WHITE}{BOLD}{sum_total:>{dtotal_w}}{RESET} {DIM}total{RESET}"
|
|
)
|
|
|
|
print(f"\n{BOLD}{CYAN}CODE QUALITY SNAPSHOT{RESET}")
|
|
# compute dynamic column widths based on values
|
|
code_items = [(l, d) for l, d in language_stats.items() if d['code_lines'] > 0]
|
|
if code_items:
|
|
files_w = max(len(str(d['files'])) for _, d in code_items)
|
|
code_w = max(len(f"{d['code_lines']:,}") for _, d in code_items)
|
|
med_w = max(len(str(d.get('median_code_lines', 0))) for _, d in code_items)
|
|
sd_w = max(len(f"{d.get('stddev_code_lines', 0):.1f}") for _, d in code_items)
|
|
avg_size_w = max(len(f"{(d.get('avg_size_kb',0)):.1f}") for _, d in code_items)
|
|
lpf_w = max(len(f"{d.get('avg_func_length', 0):.0f}") for _, d in code_items)
|
|
else:
|
|
files_w = code_w = med_w = sd_w = avg_size_w = lpf_w = 4
|
|
|
|
# Sort by quality score (descending)
|
|
def get_quality_score(item):
|
|
_, data = item
|
|
return data.get('quality_score', 0)
|
|
|
|
for language, data in sorted(code_items, key=get_quality_score, reverse=True):
|
|
comment_ratio = (data["comment_lines"] / data["code_lines"] * 100) if data["code_lines"] else 0
|
|
qs = data.get('quality_score', 0)
|
|
grade = score_grade(qs)
|
|
sc = score_color(qs, args.no_color)
|
|
avg_size = data.get("avg_size_kb", 0)
|
|
med = data.get("median_code_lines", 0)
|
|
sd = data.get("stddev_code_lines", 0)
|
|
lpf = data.get("avg_func_length", 0)
|
|
lang_color = get_lang_color(language)
|
|
# Color the comment ratio based on health
|
|
if not data.get('has_comment', True):
|
|
ratio_color = DIM
|
|
elif comment_ratio < 10:
|
|
ratio_color = RED
|
|
elif comment_ratio < 20:
|
|
ratio_color = YELLOW
|
|
else:
|
|
ratio_color = GREEN
|
|
print(
|
|
f"{sc}{grade:>2}{RESET} "
|
|
f"{lang_color}{language:<18}{RESET} "
|
|
f"{DIM}Files:{RESET}{CYAN}{data['files']:>{files_w}}{RESET} {DIM}|{RESET} "
|
|
f"{DIM}Code:{RESET}{WHITE}{data['code_lines']:>{code_w},}{RESET} {DIM}|{RESET} "
|
|
f"{DIM}L/F:{RESET}{WHITE}{lpf:>{lpf_w}.0f}{RESET} {DIM}|{RESET} "
|
|
f"{DIM}Comment:{RESET}{ratio_color}{comment_ratio:>4.1f}%{RESET} {DIM}|{RESET} "
|
|
f"{DIM}Size:{RESET}{WHITE}{avg_size:>{avg_size_w}.1f}{RESET}{DIM}kb{RESET} {DIM}|{RESET} "
|
|
f"{DIM}Score:{RESET} {sc}{qs:.0f}{RESET}"
|
|
)
|
|
|
|
# ---- CODE HEALTH REPORT ----
|
|
print(f"\n{BOLD}{MAGENTA}CODE HEALTH REPORT{RESET}")
|
|
|
|
# Compute overall quality score (weighted average by code lines)
|
|
total_code_lines = sum(d['code_lines'] for _, d in code_items)
|
|
if total_code_lines > 0:
|
|
overall_score = sum(d.get('quality_score', 0) * d['code_lines'] for _, d in code_items) / total_code_lines
|
|
else:
|
|
overall_score = 0
|
|
overall_grade = score_grade(overall_score)
|
|
osc = score_color(overall_score, args.no_color)
|
|
|
|
# Overall totals
|
|
total_funcs = sum(d['function_count'] for _, d in code_items)
|
|
total_classes = sum(d.get('class_count', 0) for _, d in code_items)
|
|
total_comments = sum(d['comment_lines'] for _, d in code_items)
|
|
total_todos = sum(d.get('todo_count', 0) for _, d in code_items)
|
|
total_imports = sum(d.get('import_count', 0) for _, d in code_items)
|
|
total_long_lines = sum(d.get('long_lines', 0) for _, d in code_items)
|
|
total_large_files = sum(d.get('large_file_count', 0) for _, d in code_items)
|
|
overall_cr = (total_comments / total_code_lines * 100) if total_code_lines else 0
|
|
overall_lpf = (total_code_lines / total_funcs) if total_funcs else 0
|
|
overall_td = (total_todos / total_code_lines * 1000) if total_code_lines else 0
|
|
max_nesting_all = max((d.get('max_nesting_depth', 0) for _, d in code_items), default=0)
|
|
all_total_lines = sum(d['code_lines'] + d['comment_lines'] + d['empty_lines'] for _, d in code_items)
|
|
overall_llr = (total_long_lines / all_total_lines * 100) if all_total_lines else 0
|
|
|
|
# Grade display
|
|
print(f"\n {BOLD}Overall Grade:{RESET} {osc}{BOLD}{overall_grade}{RESET} {DIM}({osc}{overall_score:.0f}{RESET}{DIM}/100){RESET}")
|
|
print(f" {BOLD}Quality Bar:{RESET} {horizontal_bar(overall_score, width=30, color=osc)}")
|
|
|
|
# Breakdown metrics
|
|
cr_color = GREEN if overall_cr >= 20 else (YELLOW if overall_cr >= 10 else RED)
|
|
lpf_color = GREEN if overall_lpf <= 30 else (YELLOW if overall_lpf <= 50 else RED)
|
|
td_color = GREEN if overall_td <= 5 else (YELLOW if overall_td <= 10 else RED)
|
|
nesting_color = GREEN if max_nesting_all <= 5 else (YELLOW if max_nesting_all <= 7 else RED)
|
|
llr_color = GREEN if overall_llr <= 3 else (YELLOW if overall_llr <= 8 else RED)
|
|
lf_total_files = sum(d['files'] for _, d in code_items)
|
|
lf_pct = (total_large_files / lf_total_files * 100) if lf_total_files else 0
|
|
lf_color = GREEN if lf_pct <= 15 else (YELLOW if lf_pct <= 30 else RED)
|
|
|
|
print(f"\n {BOLD}Metrics Breakdown:{RESET}")
|
|
print(f" {DIM}Comment Ratio:{RESET} {cr_color}{overall_cr:>5.1f}%{RESET} {DIM}({total_comments:,} comment lines / {total_code_lines:,} code lines){RESET}")
|
|
print(f" {DIM}Lines per Func:{RESET} {lpf_color}{overall_lpf:>5.1f}{RESET} {DIM}({total_code_lines:,} code lines / {total_funcs:,} functions){RESET}")
|
|
print(f" {DIM}TODO Density:{RESET} {td_color}{overall_td:>5.1f}{RESET} {DIM}({total_todos} TODOs per 1K lines){RESET}")
|
|
print(f" {DIM}Max Nesting:{RESET} {nesting_color}{max_nesting_all:>5}{RESET} {DIM}(deepest brace nesting across project){RESET}")
|
|
print(f" {DIM}Long Lines:{RESET} {llr_color}{overall_llr:>5.1f}%{RESET} {DIM}({total_long_lines:,} lines > 120 chars){RESET}")
|
|
print(f" {DIM}Large Files:{RESET} {lf_color}{total_large_files:>5}{RESET} {DIM}({lf_pct:.0f}% files > 300 lines){RESET}")
|
|
print(f" {DIM}Imports:{RESET} {WHITE}{total_imports:>5,}{RESET} {DIM}(total import statements){RESET}")
|
|
|
|
# Per-language quality bar chart (sorted by score)
|
|
print(f"\n {BOLD}Per-Language Scores:{RESET}")
|
|
for language, data in sorted(code_items, key=get_quality_score, reverse=True):
|
|
qs = data.get('quality_score', 0)
|
|
grade = score_grade(qs)
|
|
sc = score_color(qs, args.no_color)
|
|
lang_color = get_lang_color(language)
|
|
bar = horizontal_bar(qs, width=20, color=sc)
|
|
print(f" {lang_color}{language:<18}{RESET} {bar} {sc}{grade:>2}{RESET} {DIM}({qs:.0f}){RESET}")
|
|
|
|
print(f"\n{BOLD}{CYAN}TOP FILES ({args.top}){RESET}")
|
|
# prepare filtered list
|
|
filtered = [f for f in per_file if f['code_lines'] >= args.min_code_lines]
|
|
|
|
# compute widths for predictable columns
|
|
code_w = max((len(f"{f['code_lines']:,}") for f in filtered), default=6)
|
|
lang_w = max((len(f['language']) for f in filtered), default=8)
|
|
size_w = max((len(f"{f['size_bytes']/1024:.1f}" ) for f in filtered), default=6)
|
|
func_w = max((len(str(f['function_count'])) for f in filtered), default=4)
|
|
todo_w = max((len(str(f['todo_count'])) for f in filtered), default=3)
|
|
comment_w = max((len(f"{f['comment_ratio']:.1f}") for f in filtered), default=4)
|
|
|
|
# largest by code
|
|
largest_by_code = sorted(filtered, key=lambda x: x['code_lines'], reverse=True)[:args.top]
|
|
print(f"\n{BOLD}{PURPLE}Largest by code lines{RESET}")
|
|
for f in largest_by_code:
|
|
size_kb = f['size_bytes'] / 1024
|
|
lang_color = get_lang_color(f['language'])
|
|
print(f"{WHITE}{f['code_lines']:{code_w},}{RESET} {DIM}|{RESET} {lang_color}{f['language']:<{lang_w}}{RESET} {DIM}|{RESET} {CYAN}{size_kb:>{size_w}.1f}{RESET}{DIM}kb{RESET} {DIM}|{RESET} {DIM}funcs:{RESET}{MAGENTA}{f['function_count']:{func_w}}{RESET} {DIM}todos:{RESET}{ORANGE}{f['todo_count']:{todo_w}}{RESET} {DIM}|{RESET} {DIM}comment:{RESET}{YELLOW}{f['comment_ratio']:{comment_w}.1f}%{RESET} {TEAL}{Path(f['relpath']).relative_to(root)}{RESET}")
|
|
|
|
# Most TODOs
|
|
most_todos = sorted(filtered, key=lambda x: x['todo_count'], reverse=True)[:args.top]
|
|
print(f"\n{BOLD}{ORANGE}Files with most TODO/FIXME{RESET}")
|
|
for f in most_todos:
|
|
if f['todo_count'] == 0:
|
|
continue
|
|
lang_color = get_lang_color(f['language'])
|
|
print(f"{ORANGE}{f['todo_count']:{todo_w}}{RESET} {DIM}TODOs |{RESET} {lang_color}{f['language']:<{lang_w}}{RESET} {DIM}|{RESET} {DIM}code:{RESET}{WHITE}{f['code_lines']:{code_w},}{RESET} {DIM}|{RESET} {DIM}comment:{RESET}{YELLOW}{f['comment_ratio']:{comment_w}.1f}%{RESET} {TEAL}{Path(f['relpath']).relative_to(root)}{RESET}")
|
|
|
|
# Lowest comment ratio (but with at least some code)
|
|
low_comments = sorted((f for f in filtered if f.get('has_comment', True)), key=lambda x: x['comment_ratio'])[:args.top]
|
|
print(f"\n{BOLD}{RED}Files with lowest comment ratio{RESET} {DIM}(languages that support comments){RESET}")
|
|
for f in low_comments:
|
|
lang_color = get_lang_color(f['language'])
|
|
ratio_color = RED if f['comment_ratio'] < 5 else (YELLOW if f['comment_ratio'] < 10 else GREEN)
|
|
print(f"{ratio_color}{f['comment_ratio']:{comment_w}.1f}%{RESET} {DIM}|{RESET} {lang_color}{f['language']:<{lang_w}}{RESET} {DIM}|{RESET} {DIM}code:{RESET}{WHITE}{f['code_lines']:{code_w},}{RESET} {DIM}|{RESET} {DIM}todos:{RESET}{ORANGE}{f['todo_count']:{todo_w}}{RESET} {TEAL}{Path(f['relpath']).relative_to(root)}{RESET}")
|
|
|
|
elapsed = result.get('elapsed', 0)
|
|
workers = result.get('workers', 1)
|
|
total_files = len(result.get('per_file', []))
|
|
total_lines = sum(f['total_lines'] for f in result.get('per_file', []))
|
|
fps = f"{total_files / elapsed:,.0f} files/s" if elapsed > 0 else "N/A"
|
|
lps_raw = total_lines / elapsed if elapsed > 0 else 0
|
|
if lps_raw >= 1_000_000:
|
|
lps = f"{lps_raw / 1_000_000:.1f}M lines/s"
|
|
elif lps_raw >= 1_000:
|
|
lps = f"{lps_raw / 1_000:.1f}K lines/s"
|
|
else:
|
|
lps = f"{lps_raw:.0f} lines/s"
|
|
print(f"\n{GREEN}Analysis complete ✔{RESET} {DIM}│ {elapsed:.2f}s │ {workers} threads │ {fps} │ {lps} │ v{VERSION}{RESET}\n")
|
|
|
|
# --------------------------------------------------
|
|
# Runner
|
|
# --------------------------------------------------
|
|
|
|
def run(root: Path, args):
|
|
t0 = time.time()
|
|
|
|
language_stats = defaultdict(lambda: {
|
|
"files": 0,
|
|
"code_lines": 0,
|
|
"code_chars": 0,
|
|
"comment_lines": 0,
|
|
"empty_lines": 0,
|
|
"function_count": 0,
|
|
"class_count": 0,
|
|
"todo_count": 0,
|
|
"import_count": 0,
|
|
"long_lines": 0,
|
|
"max_nesting_depth": 0,
|
|
"nesting_depths": [],
|
|
"func_lengths": [],
|
|
"longest_lines": [],
|
|
"sizes": [],
|
|
"per_file_code_lines": [],
|
|
"has_comment": False,
|
|
})
|
|
|
|
category_totals = {
|
|
"code": 0,
|
|
"config": 0,
|
|
"docs": 0
|
|
}
|
|
|
|
per_file = []
|
|
|
|
_bypass = args.bypass_excluded
|
|
|
|
# load dynamic ignore patterns from .gitignore/.ignore files
|
|
if _bypass:
|
|
ignore_dirs = set()
|
|
ignore_globs = []
|
|
negation_globs = []
|
|
negation_dirs = set()
|
|
else:
|
|
ignore_dirs = set(IGNORE_DIRECTORIES)
|
|
ignore_globs, extra_dir_names, negation_globs, negation_dirs = load_ignore_files(root)
|
|
for d in extra_dir_names:
|
|
ignore_dirs.add(Path(d).name)
|
|
|
|
exclude_paths = [] if _bypass else [ (root / e).resolve() for e in (args.exclude or []) ]
|
|
|
|
def is_negated(rel_path: str, name: str) -> bool:
|
|
"""Check if a path matches a negation pattern (should NOT be ignored)."""
|
|
for neg_dir in negation_dirs:
|
|
if fnmatch.fnmatch(rel_path, neg_dir) or fnmatch.fnmatch(rel_path, neg_dir + '/*'):
|
|
return True
|
|
if rel_path == neg_dir or rel_path.startswith(neg_dir + '/'):
|
|
return True
|
|
for pat in negation_globs:
|
|
if fnmatch.fnmatch(rel_path, pat) or fnmatch.fnmatch(name, pat):
|
|
return True
|
|
return False
|
|
|
|
show_anim = not args.json and not args.no_color and not args.no_animation
|
|
has_excludes = bool(exclude_paths)
|
|
root_str = str(root.resolve())
|
|
_include_hidden = args.include_hidden or _bypass
|
|
_ext_filter = args.ext
|
|
_spinners = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
|
|
|
|
# ── Phase 1: Collect all file paths ──────────────────────────────────
|
|
all_file_paths = []
|
|
_last_anim = time.monotonic()
|
|
|
|
for current_path, directory_names, file_names in os.walk(root, followlinks=False):
|
|
current_path_obj = Path(current_path)
|
|
|
|
# Skip if current path is a symlink pointing outside the project
|
|
if current_path_obj.is_symlink():
|
|
try:
|
|
if not str(current_path_obj.resolve()).startswith(root_str):
|
|
directory_names[:] = []
|
|
continue
|
|
except (OSError, ValueError):
|
|
directory_names[:] = []
|
|
continue
|
|
|
|
# if current path is within an excluded path, skip descending
|
|
if has_excludes:
|
|
try:
|
|
current_res = current_path_obj.resolve()
|
|
if any(ex == current_res or ex in current_res.parents for ex in exclude_paths):
|
|
directory_names[:] = []
|
|
continue
|
|
except (OSError, ValueError):
|
|
directory_names[:] = []
|
|
continue
|
|
|
|
# prune directory_names to avoid descending into ignores/excludes/hidden
|
|
new_dirs = []
|
|
for d in directory_names:
|
|
dpath = current_path_obj / d
|
|
|
|
# Skip symlinks that might point outside the project
|
|
if dpath.is_symlink():
|
|
try:
|
|
if not str(dpath.resolve()).startswith(root_str):
|
|
continue
|
|
except (OSError, ValueError):
|
|
continue
|
|
|
|
# Calculate relative path for pattern matching
|
|
try:
|
|
rel = str(dpath.relative_to(root)).replace('\\', '/')
|
|
except ValueError:
|
|
continue
|
|
|
|
path_is_negated = is_negated(rel, d)
|
|
|
|
if d in ignore_dirs and not path_is_negated:
|
|
continue
|
|
|
|
if has_excludes:
|
|
try:
|
|
dpath_res = dpath.resolve()
|
|
if any(ex == dpath_res or ex in dpath_res.parents for ex in exclude_paths):
|
|
continue
|
|
except (OSError, ValueError):
|
|
continue
|
|
|
|
if not _include_hidden and d.startswith('.'):
|
|
continue
|
|
|
|
if not path_is_negated:
|
|
if any(fnmatch.fnmatch(rel, pat) for pat in ignore_globs):
|
|
continue
|
|
|
|
new_dirs.append(d)
|
|
directory_names[:] = new_dirs
|
|
|
|
for file in file_names:
|
|
file_path = Path(current_path) / file
|
|
if has_excludes:
|
|
try:
|
|
file_res = file_path.resolve()
|
|
except (OSError, ValueError):
|
|
continue
|
|
if any(ex == file_res or ex in file_res.parents for ex in exclude_paths):
|
|
continue
|
|
if not _bypass and should_ignore_file(file_path, root, IGNORE_FILE_PATTERNS, ignore_globs, negation_globs):
|
|
continue
|
|
if _ext_filter and file_path.suffix.lower() not in _ext_filter:
|
|
continue
|
|
all_file_paths.append(file_path)
|
|
if show_anim:
|
|
_now = time.monotonic()
|
|
if _now - _last_anim >= 0.15:
|
|
_last_anim = _now
|
|
sp = _spinners[len(all_file_paths) % len(_spinners)]
|
|
sys.stdout.write(f"\r {CYAN}{sp}{RESET} {GRAY}Discovering files... {GOLD}{len(all_file_paths):,}{RESET} ")
|
|
sys.stdout.flush()
|
|
|
|
total_to_scan = len(all_file_paths)
|
|
|
|
# ── Phase 2: Analyze files in parallel with progress ─────────────────
|
|
if show_anim:
|
|
sys.stdout.write(f"\r {GREEN}✓{RESET} {GRAY}Discovered {GOLD}{total_to_scan:,}{GRAY} files to analyze{RESET} \n")
|
|
sys.stdout.flush()
|
|
sys.stdout.write(HIDE_CURSOR)
|
|
print() # line 1 for progress bar
|
|
print() # line 2 for filename
|
|
|
|
cpu = os.cpu_count() or 1
|
|
workers = args.workers if args.workers > 0 else min(cpu, 16)
|
|
|
|
# Use processes for large workloads (true parallelism), threads for small ones (low overhead)
|
|
use_processes = total_to_scan > 500
|
|
Executor = ProcessPoolExecutor if use_processes else ThreadPoolExecutor
|
|
|
|
# Disable cyclic GC during analysis — the growing results list causes
|
|
# increasingly expensive gen2 collections that stall all threads/processes.
|
|
gc.disable()
|
|
try:
|
|
with Executor(max_workers=workers) as executor:
|
|
# Bounded submit + wait(FIRST_COMPLETED) loop:
|
|
# - Each task is a single file → one slow file only blocks one worker
|
|
# - At most (workers*4) futures in flight → O(1) per wait() call
|
|
# - Workers always have queued work → full utilization
|
|
results = []
|
|
_last_progress = time.monotonic()
|
|
processed = 0
|
|
_MAX_INFLIGHT = workers * 4
|
|
_pending = set()
|
|
_path_map = {} # future -> path
|
|
_path_iter = iter(all_file_paths)
|
|
|
|
def _submit_up_to_limit():
|
|
"""Keep _pending at _MAX_INFLIGHT futures."""
|
|
while len(_pending) < _MAX_INFLIGHT:
|
|
fp = next(_path_iter, None)
|
|
if fp is None:
|
|
return
|
|
fut = executor.submit(analyze_file, fp)
|
|
_pending.add(fut)
|
|
_path_map[fut] = fp
|
|
|
|
_submit_up_to_limit()
|
|
while _pending:
|
|
finished, _pending = wait(_pending, return_when=FIRST_COMPLETED)
|
|
for fut in finished:
|
|
processed += 1
|
|
fp = _path_map.pop(fut)
|
|
if show_anim:
|
|
_now = time.monotonic()
|
|
if _now - _last_progress >= 0.1 or processed == total_to_scan:
|
|
_last_progress = _now
|
|
try:
|
|
rel = str(fp.relative_to(root))
|
|
except ValueError:
|
|
rel = str(fp)
|
|
scan_progress(processed, total_to_scan, rel)
|
|
try:
|
|
info = fut.result()
|
|
except Exception:
|
|
info = None
|
|
if info is not None:
|
|
results.append(info)
|
|
_submit_up_to_limit()
|
|
finally:
|
|
gc.enable()
|
|
gc.collect()
|
|
|
|
if show_anim:
|
|
clear_scan_progress()
|
|
sys.stdout.write(SHOW_CURSOR)
|
|
|
|
# ── Phase 3: Accumulate results ──────────────────────────────────────
|
|
for info in results:
|
|
if info['code_lines'] < args.min_code_lines:
|
|
continue
|
|
|
|
per_file.append(info)
|
|
|
|
lang = info['language']
|
|
language_stats[lang]['files'] += 1
|
|
language_stats[lang]['code_lines'] += info['code_lines']
|
|
language_stats[lang]['code_chars'] += info['code_chars']
|
|
language_stats[lang]['comment_lines'] += info['comment_lines']
|
|
language_stats[lang]['empty_lines'] += info['empty_lines']
|
|
language_stats[lang]['function_count'] += info['function_count']
|
|
language_stats[lang]['class_count'] += info['class_count']
|
|
language_stats[lang]['todo_count'] += info['todo_count']
|
|
language_stats[lang]['import_count'] += info['import_count']
|
|
language_stats[lang]['long_lines'] += info['long_lines']
|
|
if info['max_nesting_depth'] > language_stats[lang]['max_nesting_depth']:
|
|
language_stats[lang]['max_nesting_depth'] = info['max_nesting_depth']
|
|
language_stats[lang]['nesting_depths'].append(info['max_nesting_depth'])
|
|
if info['function_count'] > 0:
|
|
language_stats[lang]['func_lengths'].append(info['avg_func_length'])
|
|
language_stats[lang]['longest_lines'].append(info['longest_line'])
|
|
language_stats[lang]['sizes'].append(info['size_bytes'])
|
|
language_stats[lang]['per_file_code_lines'].append(info['code_lines'])
|
|
language_stats[lang]['has_comment'] = language_stats[lang].get('has_comment', False) or bool(info.get('has_comment'))
|
|
|
|
category_totals[info['category']] += info['total_lines']
|
|
|
|
# ── Phase 4: Post-process language stats ─────────────────────────────
|
|
for lang, data in language_stats.items():
|
|
sizes = data['sizes']
|
|
pl = data['per_file_code_lines']
|
|
data['avg_size_kb'] = (sum(sizes) / len(sizes) / 1024) if sizes else 0
|
|
data['median_code_lines'] = int(statistics.median(pl)) if pl else 0
|
|
data['stddev_code_lines'] = statistics.pstdev(pl) if pl else 0
|
|
data['max_file_lines'] = max(pl) if pl else 0
|
|
data['large_file_count'] = sum(1 for x in pl if x > 300)
|
|
data['avg_func_length'] = (data['code_lines'] / data['function_count']) if data['function_count'] else 0
|
|
nd = data.get('nesting_depths', [])
|
|
data['avg_nesting_depth'] = (sum(nd) / len(nd)) if nd else 0
|
|
ll = data.get('longest_lines', [])
|
|
data['max_longest_line'] = max(ll) if ll else 0
|
|
data['todo_density'] = (data['todo_count'] / data['code_lines'] * 1000) if data['code_lines'] else 0
|
|
total_lines = data['code_lines'] + data['comment_lines'] + data['empty_lines']
|
|
data['long_line_ratio'] = (data['long_lines'] / total_lines * 100) if total_lines else 0
|
|
data['quality_score'] = compute_quality_score(data)
|
|
|
|
elapsed = time.time() - t0
|
|
|
|
result = {
|
|
'language_stats': language_stats,
|
|
'category_totals': category_totals,
|
|
'per_file': per_file,
|
|
'elapsed': elapsed,
|
|
'workers': workers,
|
|
}
|
|
|
|
if args.json:
|
|
out = {
|
|
'root': str(root),
|
|
'summary': {
|
|
'files': len(per_file),
|
|
'total_lines': sum(f['total_lines'] for f in per_file),
|
|
'elapsed': round(elapsed, 3),
|
|
'workers': workers,
|
|
},
|
|
'languages': {k: {"files": v['files'], "code_lines": v['code_lines'], "comment_lines": v['comment_lines']} for k, v in language_stats.items()},
|
|
'top_files': {
|
|
'largest_by_code': [ {k: f[k] for k in ('path','code_lines','size_bytes','function_count','todo_count')} for f in sorted(per_file, key=lambda x: x['code_lines'], reverse=True)[:args.top] ],
|
|
},
|
|
}
|
|
if not args.no_git:
|
|
git = get_git_info(root, args.commit_msg_max)
|
|
if git:
|
|
out['git'] = git
|
|
print(json.dumps(out, indent=2))
|
|
return result
|
|
|
|
print_summary(result, root, args)
|
|
return result
|
|
|
|
|
|
if __name__ == '__main__':
|
|
args = parse_args()
|
|
root = Path(args.path or '.').resolve()
|
|
if args.ext:
|
|
args.ext = [e if e.startswith('.') else '.' + e for e in args.ext]
|
|
|
|
# handle install/uninstall requests
|
|
if args.install or args.uninstall:
|
|
chosen = args.install_dir if args.install_dir else default_install_dir()
|
|
install_dir = os.path.expanduser(chosen)
|
|
if args.install:
|
|
ok = install_self(install_dir)
|
|
sys.exit(0 if ok else 2)
|
|
if args.uninstall:
|
|
ok = uninstall_self(install_dir)
|
|
sys.exit(0 if ok else 2)
|
|
|
|
# Startup animation (skip for JSON output, no-color, or no-animation)
|
|
if not args.json and not args.no_color and not args.no_animation:
|
|
try:
|
|
startup_sequence(root)
|
|
except Exception:
|
|
pass # graceful fallback if terminal doesn't support ANSI
|
|
|
|
try:
|
|
run(root, args)
|
|
except KeyboardInterrupt:
|
|
sys.stdout.write(SHOW_CURSOR)
|
|
print(f"\n{RED}Interrupted.{RESET}")
|
|
sys.exit(1)
|
|
|