repodoctor-cli 1.0.0__tar.gz

repodoctor_cli-1.0.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: repodoctor-cli
+Version: 1.0.0
+Summary: Zero-dependency repository health analyser
+Author: Tanish Jain, Harsh Kumawat
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: requires-python
+
+# RepoDoctor
+
+> RepoDoctor diagnoses a codebase for maintainability, security, duplication, project-structure and Git issues using only the language standard library.
+
+## Problem
+Modern development tools rely on heavy dependency chains that are hard to audit, difficult to install in restricted environments, and prone to breaking changes.
+
+## Solution
+RepoDoctor is a production-quality CLI tool that analyzes a software repository and provides an actionable health, security, and maintainability report without a single third-party runtime dependency.
+
+## Features
+- **Multi-Threaded Parallel Scanning**: Asynchronously processes massive codebases in milliseconds.\n- **Animated Terminal UI**: Beautiful typewriter animations and progress spinners.\n- **Multi-Repository Aggregation**: Scan multiple codebases simultaneously and generate unified or independent reports across all flags (HTML, JSON, LLM prompt).\n- **Zero Runtime Dependencies**: Built entirely with Python's standard library.
+- **Single-File Portability**: Can be compiled into a single `repodoctor_single.py` script for extreme portability.
+- **Developer Mood Analyzer**: Scans code comments and commit messages to calculate the emotional state of the project team.
+- **Code Clone Exposer**: Mathematically cross-references all files to expose the two most identical copy-pasted files in the project.
+- **Micro-Linter Engine**: Instantly flags 30+ code smells including profanity filters, wildcard imports, massive JSON configs, and missing alt-text.
+- **LLM Prompt Exporter**: Instantly bundle your entire codebase into a single text file ready for ChatGPT/Claude (`--export-prompt`).
+- **SVG Badge Generator**: Generate valid GitHub-style SVG health badges without image processing libraries (`--badge`).
+- **Terminal ASCII Tree & Bar Charts**: Visual breakdown of your project's folders (`--tree`) and languages natively in your terminal.
+- **AST Cyclomatic Complexity**: Parses Python Abstract Syntax Trees mathematically to score code logic complexity.
+- **Security Scanner**: Detects exposed API keys, credentials, and `.env` files and automatically redacts findings.
+- **Git Analytics & Hotspots**: Leverages native Git to report top contributors, uncommitted changes, and your most frequently edited file (Hotspot).
+- **Codebase Vocabulary Cloud**: Automatically extracts the most frequently used variable and function names across all your files.
+- **Rich Output Formats**: Choose between Animated ANSI-colored terminal, HTML (`--html`), or JSON (`--json`).
+- **Baseline Tracking**: Compare current scans against past reports (`--baseline`) to track regressions over time.
+
+## Architecture
+Modular Python architecture utilizing built-in `argparse`, `subprocess`, `ast`, and `unittest`. Data structures rely on `dataclasses`.
+
+## Installation
+No dependencies are required. Clone the repository or copy the `repodoctor` folder:
+
+```bash
+git clone https://github.com/example/repodoctor.git
+```
+
+## Usage
+Run the package directory against your target repository:
+
+```bash
+python -m repodoctor /path/to/your/repo
+```
+
+### CLI Options
+
+| Flag | Description |
+|---|---|
+| `path` | Path to the repository (default: `.`) |
+| `--json` | Output valid machine-readable JSON |
+| `--html FILE` | Output a self-contained HTML dashboard report |
+| `--export-prompt FILE`| Export the codebase into a single text file for LLM prompting |
+| `--badge FILE` | Generate a GitHub-style SVG health badge |
+| `--tree` | Print an ASCII project directory tree at the top of the report |
+| `--baseline FILE` | Path to a previous JSON report to calculate delta trends |
+| `--no-color` | Disable animated ANSI color output |
+| `--ignore` | Comma-separated list of custom directories to ignore |
+| `--large-file-lines` | Threshold for large file lines (default: 500) |
+| `--duplicate-lines` | Minimum lines for duplicate detection (default: 8) |
+| `--security` | Focus only on security analysis |
+| `--todos` | Focus only on TODO/FIXME analysis |
+| `--git` | Include Git analysis (Always attempts by default) |
+| `--verbose` | Enable verbose logging |
+| `--version` | Display version |
+| `--help` | Display help |
+
+### Exit Codes
+- `0`: Successful scan, no serious findings (secrets or duplicates).
+- `1`: Successful scan with findings.
+- `2`: Invalid CLI usage.
+
+## JSON Format
+Use the `--json` flag to export data.
+```json
+{
+  "repository": { "path": ".", "name": "project" },
+  "summary": { "files": 247, "lines": 38421, "health_score": 78 },
+  "security": { "potential_secrets": 0, "findings": [] },
+  "maintainability": { "large_files": 0, "todos": 5, "duplicates": 0 },
+  "git": { "available": true, "branch": "main", "commits": 142, "uncommitted_changes": 0 },
+  "structure": { "README": "PASS", "Tests": "PASS" }
+}
+```
+
+## Performance
+- Uses efficient filesystem walking (`os.walk`).
+- Early bailing on binary files.
+- Rolling window chunking for O(N) deduplication analysis.
+
+## Security Model
+- **Local Only**: No data is uploaded or transmitted.
+- **Redacted Output**: Secrets are never dumped fully in terminal or JSON.
+- **No Evaluation**: Source code is parsed statically (via AST/Regex), never executed.
+- **Safe Execution**: Git commands strictly avoid shell interpolation to prevent injection.
+
+## Limitations
+- Language detection is extension-based.
+- Duplicate detection is line-based rather than AST-based.
+- Security scanner may yield false positives; human review is required.
+
+## Zero-Dependency Proof
+To verify, run within a fully clean virtual environment:
+```bash
+python -m venv /tmp/repodoctor-test
+source /tmp/repodoctor-test/bin/activate
+pip freeze # (Will be empty)
+python -m repodoctor /path/to/repo1 /path/to/repo2
+```
+
+## Standard Library Substitutions
+See [STDLIB.md](STDLIB.md) for details on how we substituted common third-party tools.
+
+## Testing
+Tested with Python `unittest`:
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Hackathon Information
+Built for the **Zero Dependency | 72-Hour Hackathon**.
+
+## License
+MIT

repodoctor_cli-1.0.0/README.md

@@ -0,0 +1,122 @@
+# RepoDoctor
+
+> RepoDoctor diagnoses a codebase for maintainability, security, duplication, project-structure and Git issues using only the language standard library.
+
+## Problem
+Modern development tools rely on heavy dependency chains that are hard to audit, difficult to install in restricted environments, and prone to breaking changes.
+
+## Solution
+RepoDoctor is a production-quality CLI tool that analyzes a software repository and provides an actionable health, security, and maintainability report without a single third-party runtime dependency.
+
+## Features
+- **Multi-Threaded Parallel Scanning**: Asynchronously processes massive codebases in milliseconds.\n- **Animated Terminal UI**: Beautiful typewriter animations and progress spinners.\n- **Multi-Repository Aggregation**: Scan multiple codebases simultaneously and generate unified or independent reports across all flags (HTML, JSON, LLM prompt).\n- **Zero Runtime Dependencies**: Built entirely with Python's standard library.
+- **Single-File Portability**: Can be compiled into a single `repodoctor_single.py` script for extreme portability.
+- **Developer Mood Analyzer**: Scans code comments and commit messages to calculate the emotional state of the project team.
+- **Code Clone Exposer**: Mathematically cross-references all files to expose the two most identical copy-pasted files in the project.
+- **Micro-Linter Engine**: Instantly flags 30+ code smells including profanity filters, wildcard imports, massive JSON configs, and missing alt-text.
+- **LLM Prompt Exporter**: Instantly bundle your entire codebase into a single text file ready for ChatGPT/Claude (`--export-prompt`).
+- **SVG Badge Generator**: Generate valid GitHub-style SVG health badges without image processing libraries (`--badge`).
+- **Terminal ASCII Tree & Bar Charts**: Visual breakdown of your project's folders (`--tree`) and languages natively in your terminal.
+- **AST Cyclomatic Complexity**: Parses Python Abstract Syntax Trees mathematically to score code logic complexity.
+- **Security Scanner**: Detects exposed API keys, credentials, and `.env` files and automatically redacts findings.
+- **Git Analytics & Hotspots**: Leverages native Git to report top contributors, uncommitted changes, and your most frequently edited file (Hotspot).
+- **Codebase Vocabulary Cloud**: Automatically extracts the most frequently used variable and function names across all your files.
+- **Rich Output Formats**: Choose between Animated ANSI-colored terminal, HTML (`--html`), or JSON (`--json`).
+- **Baseline Tracking**: Compare current scans against past reports (`--baseline`) to track regressions over time.
+
+## Architecture
+Modular Python architecture utilizing built-in `argparse`, `subprocess`, `ast`, and `unittest`. Data structures rely on `dataclasses`.
+
+## Installation
+No dependencies are required. Clone the repository or copy the `repodoctor` folder:
+
+```bash
+git clone https://github.com/example/repodoctor.git
+```
+
+## Usage
+Run the package directory against your target repository:
+
+```bash
+python -m repodoctor /path/to/your/repo
+```
+
+### CLI Options
+
+| Flag | Description |
+|---|---|
+| `path` | Path to the repository (default: `.`) |
+| `--json` | Output valid machine-readable JSON |
+| `--html FILE` | Output a self-contained HTML dashboard report |
+| `--export-prompt FILE`| Export the codebase into a single text file for LLM prompting |
+| `--badge FILE` | Generate a GitHub-style SVG health badge |
+| `--tree` | Print an ASCII project directory tree at the top of the report |
+| `--baseline FILE` | Path to a previous JSON report to calculate delta trends |
+| `--no-color` | Disable animated ANSI color output |
+| `--ignore` | Comma-separated list of custom directories to ignore |
+| `--large-file-lines` | Threshold for large file lines (default: 500) |
+| `--duplicate-lines` | Minimum lines for duplicate detection (default: 8) |
+| `--security` | Focus only on security analysis |
+| `--todos` | Focus only on TODO/FIXME analysis |
+| `--git` | Include Git analysis (Always attempts by default) |
+| `--verbose` | Enable verbose logging |
+| `--version` | Display version |
+| `--help` | Display help |
+
+### Exit Codes
+- `0`: Successful scan, no serious findings (secrets or duplicates).
+- `1`: Successful scan with findings.
+- `2`: Invalid CLI usage.
+
+## JSON Format
+Use the `--json` flag to export data.
+```json
+{
+  "repository": { "path": ".", "name": "project" },
+  "summary": { "files": 247, "lines": 38421, "health_score": 78 },
+  "security": { "potential_secrets": 0, "findings": [] },
+  "maintainability": { "large_files": 0, "todos": 5, "duplicates": 0 },
+  "git": { "available": true, "branch": "main", "commits": 142, "uncommitted_changes": 0 },
+  "structure": { "README": "PASS", "Tests": "PASS" }
+}
+```
+
+## Performance
+- Uses efficient filesystem walking (`os.walk`).
+- Early bailing on binary files.
+- Rolling window chunking for O(N) deduplication analysis.
+
+## Security Model
+- **Local Only**: No data is uploaded or transmitted.
+- **Redacted Output**: Secrets are never dumped fully in terminal or JSON.
+- **No Evaluation**: Source code is parsed statically (via AST/Regex), never executed.
+- **Safe Execution**: Git commands strictly avoid shell interpolation to prevent injection.
+
+## Limitations
+- Language detection is extension-based.
+- Duplicate detection is line-based rather than AST-based.
+- Security scanner may yield false positives; human review is required.
+
+## Zero-Dependency Proof
+To verify, run within a fully clean virtual environment:
+```bash
+python -m venv /tmp/repodoctor-test
+source /tmp/repodoctor-test/bin/activate
+pip freeze # (Will be empty)
+python -m repodoctor /path/to/repo1 /path/to/repo2
+```
+
+## Standard Library Substitutions
+See [STDLIB.md](STDLIB.md) for details on how we substituted common third-party tools.
+
+## Testing
+Tested with Python `unittest`:
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Hackathon Information
+Built for the **Zero Dependency | 72-Hour Hackathon**.
+
+## License
+MIT

repodoctor_cli-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+# PEP 517 / 518 — build backend is setuptools (stdlib-bundled, zero new installs)
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "repodoctor-cli"
+version = "1.0.0"
+description = "Zero-dependency repository health analyser"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = []   # ZERO runtime dependencies
+license = { text = "MIT" }
+authors = [
+    { name = "Tanish Jain, Harsh Kumawat" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Quality Assurance",
+    "Environment :: Console",
+]
+
+[project.scripts]
+repodoctor = "repodoctor.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["repodoctor*"]

repodoctor_cli-1.0.0/repodoctor/__init__.py

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

repodoctor_cli-1.0.0/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()