repodoctor-cli 1.0.0__py3-none-any.whl

repodoctor/__init__.py

@@ -0,0 +1 @@
+"""RepoDoctor package"""

repodoctor/__main__.py

@@ -0,0 +1,370 @@
+import sys
+import os
+import time
+import re
+import concurrent.futures
+import collections
+import io
+import contextlib
+
+# Force utf-8 output to avoid cp1252 encoding errors on Windows
+if sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+    except Exception:
+        pass
+
+from .cli import parse_args
+from .scanner import scan_repository
+from .languages import detect_languages
+from .metrics import analyze_metrics
+from .todos import scan_todos
+from .security import scan_security
+from .duplicates import scan_duplicates
+from .structure import check_project_structure
+from .git import get_git_info
+from .scoring import calculate_score
+from .report import print_terminal_report, get_json_report, generate_html_report
+from .baseline import compare_baseline
+from .models import ReportData
+from .spinner import Spinner
+
+def process_single_repo(root_path, args, idx, custom_ignores, use_parallel, show_animation, start_time):
+    repo_start_time = time.time()
+    # Determine if we should suppress live spinner output (if scanning multiple repos)
+    silent = len(args.path) > 1
+
+    # 1. Scan files
+    files = scan_repository(
+        root_path,
+        custom_ignores,
+        parallel=use_parallel,
+        show_animation=show_animation and not silent,
+    )
+
+    # 2. Run analysis phases
+    with Spinner(f"Detecting languages ({root_path})", colour=show_animation, silent=silent):
+        detect_languages(files)
+
+    with Spinner(f"Analysing metrics ({root_path})", colour=show_animation, silent=silent):
+        analyze_metrics(files)
+
+    with Spinner(f"Scanning TODOs ({root_path})", colour=show_animation, silent=silent):
+        todos = scan_todos(files)
+
+    with Spinner(f"Scanning security patterns ({root_path})", colour=show_animation, silent=silent):
+        security = scan_security(files)
+
+    with Spinner(f"Detecting duplicates ({root_path})", colour=show_animation, silent=silent):
+        duplicates = scan_duplicates(files, args.duplicate_lines)
+
+    with Spinner(f"Checking project structure ({root_path})", colour=show_animation, silent=silent):
+        structure = check_project_structure(root_path)
+
+    with Spinner(f"Reading Git info ({root_path})", colour=show_animation, silent=silent):
+        git_info = get_git_info(root_path)
+
+    repo_name = os.path.basename(os.path.abspath(root_path)) or "Unknown"
+
+    # AI & Advanced analytics (computed just in time)
+    all_words = []
+    for f in files:
+        try:
+            with open(f.path, 'r', encoding='utf-8', errors='ignore') as file_handle:
+                content = file_handle.read()
+                f._words = re.findall(r'\b[a-zA-Z_]{3,}\b', content)
+                all_words.extend(f._words)
+        except Exception:
+            f._words = []
+
+    positive_words = {"awesome", "great", "excellent", "amazing", "good", "perfect", "wow", "love", "thanks", "beautiful", "brilliant", "clean", "elegant", "smart"}
+    negative_words = {"fuck", "shit", "crap", "bitch", "damn", "hate", "ugly", "stupid", "terrible", "awful", "horrible", "mess", "hack", "fixme", "gross", "disgusting", "wtf"}
+    
+    pos_count = sum(1 for f in files for w in getattr(f, "_words", []) if w.lower() in positive_words)
+    neg_count = sum(1 for f in files for w in getattr(f, "_words", []) if w.lower() in negative_words)
+    
+    if pos_count == 0 and neg_count == 0:
+        mood_str = "Neutral 😐 (0 positive, 0 negative words)"
+    elif pos_count > neg_count * 2:
+        mood_str = f"Highly Motivated 🚀 ({pos_count} positive, {neg_count} negative words)"
+    elif neg_count > pos_count * 2:
+        mood_str = f"Severely Frustrated 😡 ({pos_count} positive, {neg_count} negative words)"
+    else:
+        mood_str = f"Balanced ⚖️ ({pos_count} positive, {neg_count} negative words)"
+        
+    clone_str = "No major clones detected 👏"
+    if len(files) > 1:
+        try:
+            import difflib
+            texts = [(f, " ".join(getattr(f, "_words", []))) for f in files if len(getattr(f, "_words", [])) > 50]
+            if len(texts) > 1:
+                texts.sort(key=lambda x: len(x[1]), reverse=True)
+                top_files = texts[:10]
+                best_ratio = 0
+                best_pair = None
+                for i in range(len(top_files)):
+                    for j in range(i+1, len(top_files)):
+                        ratio = difflib.SequenceMatcher(None, top_files[i][1], top_files[j][1]).quick_ratio()
+                        if ratio > best_ratio:
+                            best_ratio = ratio
+                            best_pair = (top_files[i][0].path, top_files[j][0].path)
+                if best_ratio > 0.8:
+                    clone_str = f"{best_pair[0]} & {best_pair[1]} ({int(best_ratio*100)}% identical)"
+        except Exception:
+            pass
+
+    stop_words = {"the", "and", "but", "for", "with", "was", "were", "been", "being", "have", "has", "had", "will", "would", "shall", "should", "can", "could", "may", "might", "must", "then", "else", "while", "def", "class", "return", "import", "from", "print", "self", "None", "True", "False"}
+    filtered_words = [w for w in all_words if len(w) > 3 and w.lower() not in stop_words]
+    top_words = collections.Counter(filtered_words).most_common(5)
+
+    data = ReportData(
+        path=os.path.abspath(root_path),
+        name=repo_name,
+        files=files,
+        todos=todos,
+        security=security,
+        duplicates=duplicates,
+        structure=structure,
+        git=git_info,
+        score=None
+    )
+    
+    data.mood = mood_str
+    data.clone_exposer = clone_str
+    data.top_words = top_words
+
+    score = calculate_score(data)
+    data.score = score
+
+    local_exit_code = 0
+    if score and score.score < getattr(args, "fail_under", 0):
+        local_exit_code = 1
+
+    deltas = None
+    if getattr(args, "baseline", None) and os.path.exists(args.baseline):
+        try:
+            import json
+            with open(args.baseline, "r") as bf:
+                base_data = json.load(bf)
+                if "score" in base_data and data.score:
+                    deltas = {"score": data.score.score - base_data["score"]}
+        except Exception:
+            pass
+
+    # Generate badge SVG
+    badge_svg = None
+    badge_path = None
+    if getattr(args, "badge", None):
+        color = "#4c1" if score.score >= 90 else ("#dfb317" if score.score >= 70 else "#e05d44")
+        badge_svg = f'''<svg xmlns="http://www.w3.org/2000/svg" width="140" height="20">
+  <linearGradient id="b" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <mask id="a">
+    <rect width="140" height="20" rx="3" fill="#fff"/>
+  </mask>
+  <g mask="url(#a)">
+    <path fill="#555" d="M0 0h80v20H0z"/>
+    <path fill="{color}" d="M80 0h60v20H0z"/>
+    <path fill="url(#b)" d="M0 0h140v20H0z"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
+    <text x="40" y="15" fill="#010101" fill-opacity=".3">RepoDoctor</text>
+    <text x="40" y="14">RepoDoctor</text>
+    <text x="109" y="15" fill="#010101" fill-opacity=".3">{score.score}/100</text>
+    <text x="109" y="14">{score.score}/100</text>
+  </g>
+</svg>'''
+        badge_path = args.badge
+        if len(args.path) > 1:
+            base, ext = os.path.splitext(badge_path)
+            badge_path = f"{base}_{idx+1}{ext}"
+
+    # Capture terminal report
+    terminal_report = ""
+    repo_duration = time.time() - repo_start_time
+    if not args.json:
+        f_buf = io.StringIO()
+        with contextlib.redirect_stdout(f_buf):
+            use_color = not args.no_color and sys.stdout.isatty()
+            print_terminal_report(data, use_color, args.large_file_lines, deltas, repo_duration, getattr(args, 'tree', False))
+        terminal_report = f_buf.getvalue()
+
+    # Generate JSON
+    json_report = None
+    if args.json:
+        from .report import get_json_report
+        import json
+        json_report = json.loads(get_json_report(data, args.large_file_lines))
+
+    # Generate HTML
+    html_report = None
+    if args.html:
+        html_report = generate_html_report(data, args.large_file_lines)
+
+    # Generate LLM Export
+    llm_report = None
+    if args.export_prompt:
+        prompt_chunk = f"=== REPOSITORY: {repo_name} ===\n\n"
+        for file_info in files:
+            prompt_chunk += f"--- {file_info.path} ---\n"
+            try:
+                with open(file_info.path, "r", encoding="utf-8", errors="ignore") as src:
+                    prompt_chunk += src.read() + "\n\n"
+            except Exception:
+                prompt_chunk += "[Error reading file contents]\n\n"
+        llm_report = prompt_chunk
+
+    return {
+        "idx": idx,
+        "repo_name": repo_name,
+        "exit_code": local_exit_code,
+        "badge_svg": badge_svg,
+        "badge_path": badge_path,
+        "terminal_report": terminal_report,
+        "json_report": json_report,
+        "html_report": html_report,
+        "llm_report": llm_report,
+        "duration": repo_duration,
+    }
+
+def main():
+    start_time = time.time()
+    args = parse_args()
+
+    # 1. Print Banner & Greeting
+    use_color = not args.no_color and sys.stdout.isatty()
+    def c(text, code):
+        return f"\033[{code}m{text}\033[0m" if use_color else text
+
+    if not args.json:
+        print()
+        print(c("╔════════════════════════════════════════════════════════════╗", "94;1"))
+        print(c("║                        ", "94;1"), end="")
+        for char in "REPO DOCTOR":
+            print(c(char, "96;1"), end="")
+            sys.stdout.flush()
+            time.sleep(0.05)
+        print(c("                         ║", "94;1"))
+        print(c("╚════════════════════════════════════════════════════════════╝", "94;1"))
+        print(c("Welcome to RepoDoctor! 🩺", "92;1"))
+        print(c("Initializing zero-dependency static analysis engine...", "90;1"))
+        print()
+        time.sleep(0.5)
+
+    root_paths = args.path
+    if not root_paths:
+        root_paths = ['.']
+
+    # Validate all directories first
+    for rp in root_paths:
+        if not os.path.isdir(rp):
+            print(f"Error: {rp} is not a directory.")
+            sys.exit(2)
+
+    custom_ignores = args.ignore.split(",") if args.ignore else []
+    show_animation = not getattr(args, "no_animation", False)
+    use_parallel   = getattr(args, "parallel", False)
+
+    html_outputs = []
+    json_outputs = []
+    llm_outputs = []
+    exit_code = 0
+
+    # If scanning multiple repositories, notify the user we are processing them in parallel
+    if len(root_paths) > 1 and not args.json:
+        print(c(f"Starting parallel analysis on {len(root_paths)} repositories...", "96"))
+        print()
+
+    # Use ThreadPoolExecutor to run analyses in parallel
+    analysis_start_time = time.time()
+    max_workers = min(len(root_paths), (os.cpu_count() or 1) + 4)
+    results = []
+    
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {
+            executor.submit(
+                process_single_repo, rp, args, idx, custom_ignores, use_parallel, show_animation, start_time
+            ): rp
+            for idx, rp in enumerate(root_paths)
+        }
+        for future in concurrent.futures.as_completed(futures):
+            rp = futures[future]
+            try:
+                res = future.result()
+                results.append(res)
+                if len(root_paths) > 1 and not args.json:
+                    print(c(f"✔  Completed analysis of {res['repo_name']}", "92"))
+            except Exception as e:
+                print(f"Error analyzing {rp}: {e}", file=sys.stderr)
+                exit_code = max(exit_code, 1)
+
+    if len(root_paths) > 1 and not args.json:
+        print()
+        print(c("All analyses completed. Generating reports...", "90"))
+        print()
+
+    # Sort results by their original path order to keep output deterministic
+    results.sort(key=lambda x: x["idx"])
+
+    for res in results:
+        # Update exit code
+        exit_code = max(exit_code, res["exit_code"])
+
+        # Write Badge
+        if res["badge_path"] and res["badge_svg"]:
+            try:
+                with open(res["badge_path"], "w", encoding="utf-8") as bf:
+                    bf.write(res["badge_svg"])
+            except Exception:
+                pass
+
+        # Print Terminal Report
+        if not args.json and res["terminal_report"]:
+            print(res["terminal_report"])
+
+        # Accumulate reports
+        if res["json_report"] is not None:
+            json_outputs.append(res["json_report"])
+        if res["html_report"] is not None:
+            html_outputs.append(res["html_report"])
+        if res["llm_report"] is not None:
+            llm_outputs.append(res["llm_report"])
+
+    if args.json and json_outputs:
+        import json
+        if len(json_outputs) == 1:
+            print(json.dumps(json_outputs[0], indent=2))
+        else:
+            print(json.dumps(json_outputs, indent=2))
+            
+    if args.html and html_outputs:
+        try:
+            with open(args.html, "w", encoding="utf-8") as f:
+                f.write("\n<hr>\n<br><br>\n".join(html_outputs))
+            print(f"HTML report successfully written to {args.html}")
+        except Exception as e:
+            print(f"Failed to write HTML report: {e}")
+            sys.exit(3)
+            
+    if args.export_prompt and llm_outputs:
+        try:
+            with open(args.export_prompt, "w", encoding="utf-8") as f:
+                f.write("\n\n".join(llm_outputs))
+            print(f"LLM prompt successfully exported to {args.export_prompt}")
+        except Exception as e:
+            print(f"Failed to export LLM prompt: {e}")
+            sys.exit(3)
+
+    if len(root_paths) > 1 and not args.json:
+        total_analysis_time = time.time() - analysis_start_time
+        print(c("────────────────────────────────────────────────────────────", "90"))
+        print(c(f"⚡ Concurrently analyzed {len(root_paths)} repositories in {total_analysis_time:.2f}s", "96;1"))
+        print(c("────────────────────────────────────────────────────────────", "90"))
+        print()
+
+    sys.exit(exit_code)
+
+if __name__ == "__main__":
+    main()

repodoctor/baseline.py

@@ -0,0 +1,42 @@
+import json
+import os
+from typing import Dict, Optional
+from .models import ReportData
+
+def compare_baseline(current_data: ReportData, baseline_path: str) -> Optional[Dict[str, int]]:
+    if not os.path.exists(baseline_path):
+        return None
+        
+    try:
+        with open(baseline_path, 'r', encoding='utf-8') as f:
+            baseline = json.load(f)
+            
+        deltas = {}
+        
+        # Current values
+        c_score = current_data.score.score if current_data.score else 0
+        c_files = len(current_data.files)
+        c_lines = sum(f.lines for f in current_data.files)
+        c_todos = len(current_data.todos)
+        c_dups = len(current_data.duplicates)
+        c_secrets = len(current_data.security)
+        
+        # Baseline values
+        b_score = baseline.get("summary", {}).get("health_score", 0)
+        b_files = baseline.get("summary", {}).get("files", 0)
+        b_lines = baseline.get("summary", {}).get("lines", 0)
+        b_todos = baseline.get("maintainability", {}).get("todos", 0)
+        b_dups = baseline.get("maintainability", {}).get("duplicates", 0)
+        b_secrets = baseline.get("security", {}).get("potential_secrets", 0)
+        
+        deltas["score"] = c_score - (b_score or 0)
+        deltas["files"] = c_files - b_files
+        deltas["lines"] = c_lines - b_lines
+        deltas["todos"] = c_todos - b_todos
+        deltas["duplicates"] = c_dups - b_dups
+        deltas["secrets"] = c_secrets - b_secrets
+        
+        return deltas
+        
+    except Exception:
+        return None

repodoctor/cli.py

@@ -0,0 +1,47 @@
+import argparse
+import sys
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="repodoctor",
+        description="RepoDoctor diagnoses a codebase for maintainability, security, duplication, project-structure and Git issues using only the language standard library.",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    parser.add_argument(
+        "path",
+        help="Path to the repository to analyze",
+        default=["."],
+        nargs="*"
+    )
+    parser.add_argument("--json", action="store_true", help="Output valid machine-readable JSON")
+    parser.add_argument("--html", type=str, help="Output a self-contained HTML report to the specified file", default="")
+    parser.add_argument("--baseline", type=str, help="Path to a previous JSON report to compare against", default="")
+    parser.add_argument("--no-color", action="store_true", help="Disable ANSI color output")
+    parser.add_argument("--badge", type=str, metavar="FILE", help="Generate an SVG health badge", default="")
+    parser.add_argument("--tree", action="store_true", help="Print an ASCII project tree")
+    parser.add_argument("--export-prompt", type=str, metavar="FILE", help="Export the codebase into a single text file for LLM prompting", default="")
+    parser.add_argument("--ignore", type=str, help="Comma-separated list of custom directories to ignore", default="")
+    parser.add_argument("--large-file-lines", type=int, help="Threshold for large file lines", default=500)
+    parser.add_argument("--duplicate-lines", type=int, help="Minimum lines for duplicate detection", default=8)
+    parser.add_argument("--security", action="store_true", help="Focus only on security analysis")
+    parser.add_argument("--todos", action="store_true", help="Focus only on TODO/FIXME analysis")
+    parser.add_argument("--git", action="store_true", help="Include Git analysis")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose logging")
+    parser.add_argument(
+        "--parallel", "-j",
+        action="store_true",
+        help="Enable parallel file scanning using concurrent.futures.ThreadPoolExecutor (faster on large repos)"
+    )
+    parser.add_argument(
+        "--no-animation",
+        action="store_true",
+        help="Disable live CLI spinner / progress bar animation"
+    )
+    parser.add_argument("--version", action="version", version="%(prog)s 1.0.0")
+
+    return parser
+
+def parse_args(args=None):
+    parser = build_parser()
+    return parser.parse_args(args)

repodoctor/duplicates.py

@@ -0,0 +1,69 @@
+import hashlib
+from typing import List, Dict, Tuple
+from collections import defaultdict
+from .models import FileInfo, DuplicateBlock
+
+def normalize_line(line: str) -> str:
+    """Strip whitespace and ignore if it's too short to be useful code."""
+    return line.strip()
+
+def scan_duplicates(files: List[FileInfo], min_lines: int = 8) -> List[DuplicateBlock]:
+    block_hashes = defaultdict(list)
+    duplicates = []
+
+    for f in files:
+        if f.is_binary:
+            continue
+
+        try:
+            with open(f.path, 'r', encoding='utf-8', errors='ignore') as file:
+                lines = file.readlines()
+        except Exception:
+            continue
+
+        valid_lines = []
+        for idx, line in enumerate(lines):
+            norm = normalize_line(line)
+            # basic ignore for very short lines, blank lines, or common comments
+            if not norm or len(norm) < 4 or norm.startswith('#') or norm.startswith('//'):
+                continue
+            valid_lines.append((idx + 1, norm))
+
+        if len(valid_lines) < min_lines:
+            continue
+
+        # Create rolling window of hashes
+        for i in range(len(valid_lines) - min_lines + 1):
+            window = valid_lines[i:i + min_lines]
+            start_line = window[0][0]
+            end_line = window[-1][0]
+            
+            # Create block text
+            block_text = "".join(x[1] for x in window)
+            h = hashlib.sha256(block_text.encode('utf-8')).hexdigest()
+            
+            block_hashes[h].append((f.relative_path, start_line, end_line))
+
+    # Find duplicates
+    # Since rolling windows produce overlapping duplicates, we should just report them simply.
+    # A true robust algorithm would merge overlapping blocks, but for MVP we just report unique combinations.
+    reported_combinations = set()
+
+    for h, occurrences in block_hashes.items():
+        if len(occurrences) > 1:
+            paths = [occ[0] for occ in occurrences]
+            
+            # Simple deduplication of reports (e.g. if we have 9 duplicated lines, it will create two 8-line blocks)
+            # We just take the first start_line and end_line for simplicity in MVP.
+            combo_key = tuple(sorted(paths))
+            if combo_key not in reported_combinations:
+                # Approximate the lines
+                # The format is just showing that these files share duplicate code blocks.
+                duplicates.append(DuplicateBlock(
+                    filepaths=paths,
+                    lines=(occurrences[0][1], occurrences[0][2]),
+                    similarity="exact"
+                ))
+                reported_combinations.add(combo_key)
+
+    return duplicates

repodoctor/git.py

@@ -0,0 +1,67 @@
+import subprocess
+import os
+from .models import GitInfo
+
+def run_git(cmd: list, cwd: str) -> str:
+    try:
+        result = subprocess.run(
+            ["git"] + cmd,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError):
+        return ""
+
+def get_git_info(root_path: str) -> GitInfo:
+    root = os.path.abspath(root_path)
+    
+    is_git_repo = run_git(["rev-parse", "--is-inside-work-tree"], root)
+    if is_git_repo != "true":
+        return GitInfo(available=False)
+
+    branch = run_git(["branch", "--show-current"], root)
+    if not branch:
+        branch = "detached"
+
+    commits_str = run_git(["rev-list", "--count", "HEAD"], root)
+    commits = int(commits_str) if commits_str.isdigit() else 0
+
+    status_str = run_git(["status", "--porcelain"], root)
+    uncommitted = len(status_str.splitlines()) if status_str else 0
+
+    top_contributor = ""
+    try:
+        result = subprocess.run(["git", "shortlog", "-sn", "HEAD"], cwd=root, capture_output=True, text=True, check=True)
+        lines = result.stdout.splitlines()
+        if lines and lines[0]:
+            parts = lines[0].strip().split('\t', 1)
+            if len(parts) == 2:
+                top_contributor = f"{parts[1].strip()} ({parts[0].strip()} commits)"
+    except Exception:
+        pass
+
+    hotspot = ""
+    try:
+        result = subprocess.run(["git", "log", "--name-only", "--pretty=format:"], cwd=root, capture_output=True, text=True, check=True)
+        files = [f for f in result.stdout.split('\n') if f.strip()]
+        if files:
+            from collections import Counter
+            c = Counter(files)
+            most_common = c.most_common(1)
+            if most_common:
+                hotspot = f"{most_common[0][0]} ({most_common[0][1]} edits)"
+    except Exception:
+        pass
+
+    return GitInfo(
+        available=True,
+        branch=branch,
+        uncommitted_changes=uncommitted,
+        commits=commits,
+        top_contributor=top_contributor,
+        hotspot=hotspot
+    )

repodoctor/languages.py

@@ -0,0 +1,33 @@
+from .models import FileInfo
+from typing import List
+
+EXTENSION_MAP = {
+    ".py": "Python",
+    ".js": "JavaScript",
+    ".ts": "TypeScript",
+    ".java": "Java",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".c": "C",
+    ".h": "C/C++",
+    ".cpp": "C++",
+    ".hpp": "C++",
+    ".cs": "C#",
+    ".kt": "Kotlin",
+    ".rb": "Ruby",
+    ".php": "PHP",
+    ".html": "HTML",
+    ".css": "CSS",
+    ".json": "JSON",
+    ".yaml": "YAML",
+    ".yml": "YAML",
+    ".md": "Markdown",
+    ".sh": "Shell",
+    ".sql": "SQL"
+}
+
+def detect_languages(files: List[FileInfo]) -> None:
+    for f in files:
+        if f.is_binary:
+            continue
+        f.language = EXTENSION_MAP.get(f.extension, "Unknown")