devdoctor-cli 0.1.0__py3-none-any.whl

devdoctor/project.py

@@ -0,0 +1,223 @@
+"""Project detector: inspects files and config to determine project type and tech stack."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+from devdoctor.models import ProjectInfo
+
+
+def parse_requirements_txt(file_path: Path) -> Dict[str, str]:
+    """Extract package names and version specifiers from a requirements.txt file."""
+    deps: Dict[str, str] = {}
+    if not file_path.is_file():
+        return deps
+    try:
+        content = file_path.read_text(encoding="utf-8", errors="replace")
+        for line in content.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or line.startswith("-"):
+                continue
+            # Match package name and optional version specifier
+            match = re.match(r"^([A-Za-z0-9_.\-]+)\s*([<>=!~].*)?$", line)
+            if match:
+                pkg = match.group(1).lower().replace("_", "-")
+                spec = match.group(2).strip() if match.group(2) else "*"
+                deps[pkg] = spec
+    except Exception:
+        pass
+    return deps
+
+
+def parse_pyproject_deps(file_path: Path) -> Dict[str, str]:
+    """Parse dependencies from pyproject.toml."""
+    deps: Dict[str, str] = {}
+    if not file_path.is_file():
+        return deps
+    try:
+        content = file_path.read_text(encoding="utf-8", errors="replace")
+        # Match standard PEP 621 dependencies list: dependencies = [ ... ]
+        in_deps = False
+        for line in content.splitlines():
+            line = line.strip()
+            if re.match(r"^dependencies\s*=\s*\[", line):
+                in_deps = True
+                continue
+            if in_deps:
+                if line.startswith("]"):
+                    in_deps = False
+                    continue
+                # Match quoted string like "fastapi>=0.100.0"
+                match = re.search(r'["\']([A-Za-z0-9_.\-]+)([^"\']*)["\']', line)
+                if match:
+                    pkg = match.group(1).lower().replace("_", "-")
+                    spec = match.group(2).strip() or "*"
+                    deps[pkg] = spec
+    except Exception:
+        pass
+    return deps
+
+
+def detect_project(project_path: Path) -> ProjectInfo:
+    """Analyze the project directory and build a deterministic ProjectInfo profile."""
+    root = project_path.resolve()
+    name = root.name
+
+    config_files: List[str] = []
+    technologies: List[str] = ["Python"]
+    frameworks: List[str] = []
+    project_type: Optional[str] = None
+    dependencies: Dict[str, str] = {}
+
+    # Check key files
+    known_files = [
+        "pyproject.toml",
+        "requirements.txt",
+        "setup.py",
+        "manage.py",
+        "Dockerfile",
+        "docker-compose.yml",
+        "docker-compose.yaml",
+        "compose.yaml",
+        "compose.yml",
+        ".env",
+        ".env.example",
+        ".git",
+        "alembic.ini",
+        "package.json",
+        "Pipfile",
+        "poetry.lock",
+    ]
+
+    for fname in known_files:
+        if (root / fname).exists():
+            config_files.append(fname)
+
+    # Collect dependencies
+    if (root / "requirements.txt").exists():
+        dependencies.update(parse_requirements_txt(root / "requirements.txt"))
+    if (root / "pyproject.toml").exists():
+        dependencies.update(parse_pyproject_deps(root / "pyproject.toml"))
+
+    dep_keys = set(dependencies.keys())
+
+    # Detect Django
+    if (root / "manage.py").exists() or "django" in dep_keys:
+        project_type = "Django"
+        frameworks.append("Django")
+        if "Django" not in technologies:
+            technologies.append("Django")
+
+    # Detect FastAPI
+    elif "fastapi" in dep_keys:
+        project_type = "FastAPI"
+        frameworks.append("FastAPI")
+        if "FastAPI" not in technologies:
+            technologies.append("FastAPI")
+
+    # Detect Flask
+    elif "flask" in dep_keys:
+        project_type = "Flask"
+        frameworks.append("Flask")
+        if "Flask" not in technologies:
+            technologies.append("Flask")
+
+    # Check AST or code if not found via dependencies
+    if not project_type:
+        for py_file in ["main.py", "app.py", "api.py", "server.py"]:
+            candidate = root / py_file
+            if candidate.is_file():
+                try:
+                    text = candidate.read_text(encoding="utf-8", errors="replace")
+                    if "FastAPI(" in text or "from fastapi import" in text:
+                        project_type = "FastAPI"
+                        frameworks.append("FastAPI")
+                        if "FastAPI" not in technologies:
+                            technologies.append("FastAPI")
+                        break
+                    elif "Flask(" in text or "from flask import" in text:
+                        project_type = "Flask"
+                        frameworks.append("Flask")
+                        if "Flask" not in technologies:
+                            technologies.append("Flask")
+                        break
+                except Exception:
+                    pass
+
+    if not project_type:
+        project_type = "Generic Python"
+
+    # Detect Docker
+    has_docker = (
+        (root / "Dockerfile").exists()
+        or (root / "docker-compose.yml").exists()
+        or (root / "docker-compose.yaml").exists()
+        or (root / "compose.yaml").exists()
+        or (root / "compose.yml").exists()
+    )
+    if has_docker:
+        technologies.append("Docker")
+
+    # Detect Compose contents for database and cache services
+    compose_content = ""
+    for cfile in ["docker-compose.yml", "docker-compose.yaml", "compose.yaml", "compose.yml"]:
+        target = root / cfile
+        if target.is_file():
+            try:
+                compose_content += "\n" + target.read_text(encoding="utf-8", errors="replace").lower()
+            except Exception:
+                pass
+
+    # Read .env if present
+    env_content = ""
+    if (root / ".env").is_file():
+        try:
+            env_content = (root / ".env").read_text(encoding="utf-8", errors="replace").lower()
+        except Exception:
+            pass
+
+    # Detect PostgreSQL
+    if (
+        "postgres" in compose_content
+        or "psql" in compose_content
+        or "psycopg" in dep_keys
+        or "psycopg2" in dep_keys
+        or "psycopg2-binary" in dep_keys
+        or "asyncpg" in dep_keys
+        or "postgresql://" in env_content
+        or "postgres://" in env_content
+    ):
+        technologies.append("PostgreSQL")
+
+    # Detect Redis
+    if (
+        "redis" in compose_content
+        or "redis" in dep_keys
+        or "redis://" in env_content
+    ):
+        technologies.append("Redis")
+
+    # Detect Celery
+    if "celery" in dep_keys or "celery" in compose_content:
+        technologies.append("Celery")
+
+    # Detect Alembic
+    if (root / "alembic.ini").exists() or "alembic" in dep_keys:
+        technologies.append("Alembic")
+
+    # Detect Node.js
+    if (root / "package.json").exists():
+        technologies.append("Node.js")
+
+    return ProjectInfo(
+        root=root,
+        name=name,
+        project_type=project_type,
+        technologies=technologies,
+        frameworks=frameworks,
+        config_files=config_files,
+        dependencies=dependencies,
+    )

devdoctor/reporter.py

@@ -0,0 +1,193 @@
+"""DevDoctor output reporter: renders deterministic CLI views, verbose diagnostics, and JSON."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Optional
+
+from rich.console import Console
+
+# Ensure UTF-8 output on Windows terminals
+if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+if sys.stderr and hasattr(sys.stderr, "reconfigure"):
+    try:
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+# Configure Console with legacy_windows=False to prevent charmap encoding errors
+console = Console(legacy_windows=False)
+
+# Unicode characters with safe ASCII fallbacks if required
+def can_encode(char: str) -> bool:
+    try:
+        char.encode(sys.stdout.encoding or "utf-8")
+        return True
+    except Exception:
+        return False
+
+SYM_OK = "✓" if can_encode("✓") else "[OK]"
+SYM_WARN = "⚠" if can_encode("⚠") else "[!]"
+SYM_ERR = "❌" if can_encode("❌") else "[X]"
+SYM_DIV = "────────────────────────────" if can_encode("─") else "----------------------------"
+
+
+class Reporter:
+    """Renders DiagnosticReports into terminal, verbose, JSON, or Markdown formats."""
+
+    def __init__(self, console_instance: Optional[Console] = None):
+        self.console = console_instance or console
+
+    def render_terminal(self, report: DiagnosticReport, verbose: bool = False) -> None:
+        """Render the default or verbose DevDoctor scan output to the terminal."""
+        if verbose:
+            self._render_verbose(report)
+            return
+
+        # Header
+        self.console.print("[bold cyan]DevDoctor 0.1.0[/bold cyan]")
+        if report.project_info and report.project_info.summary_stack:
+            self.console.print(f"[dim]Project: {report.project_info.summary_stack}[/dim]")
+        self.console.print(f"{SYM_DIV}\n")
+
+        # 1. Passed checks (compact green checkmarks)
+        if report.passed:
+            for diag in report.passed:
+                self.console.print(f"[green]{SYM_OK}[/green] {diag.title}")
+            self.console.print()
+
+        # 2. Problems (Warnings and Errors)
+        if report.problems:
+            for diag in report.problems:
+                sym = f"[red]{SYM_ERR}[/red]" if diag.is_error else f"[yellow]{SYM_WARN}[/yellow]"
+                self.console.print(f"{sym} [bold]{diag.title}[/bold]")
+                if diag.message:
+                    self.console.print(f"   {diag.message}\n")
+
+                if diag.evidence:
+                    self.console.print(f"   {diag.evidence}\n")
+
+                if diag.fix:
+                    self.console.print("   Fix:")
+                    for line in diag.fix.splitlines():
+                        self.console.print(f"     {line}")
+                    self.console.print()
+
+        # 3. Score
+        score = report.score
+        if score >= 90:
+            score_color = "green"
+        elif score >= 70:
+            score_color = "yellow"
+        else:
+            score_color = "red"
+
+        self.console.print(f"[bold {score_color}]Score: {score}/100[/bold {score_color}]\n")
+
+        # 4. Summary
+        total_p = report.total_problems
+        if total_p == 0:
+            self.console.print(f"[bold green]{SYM_OK} All checks passed! Machine and project are healthy.[/bold green]")
+        else:
+            problem_word = "problem" if total_p == 1 else "problems"
+            color = "red" if report.errors else "yellow"
+            self.console.print(f"[{color}]{total_p} {problem_word} found.[/{color}]")
+
+    def _render_verbose(self, report: DiagnosticReport) -> None:
+        """Render full diagnostic detail with WHY, EVIDENCE, SAFE FIX, COMMAND, and Confidence."""
+        self.console.print("[bold cyan]DevDoctor 0.1.0 (Detailed Diagnostic Report)[/bold cyan]")
+        self.console.print(f"{SYM_DIV * 2}\n")
+
+        if report.passed:
+            self.console.print("[bold green]PASSED CHECKS:[/bold green]")
+            for diag in report.passed:
+                self.console.print(f"  [green]{SYM_OK}[/green] {diag.title}: {diag.message}")
+            self.console.print()
+
+        if report.problems:
+            self.console.print("[bold red]IDENTIFIED PROBLEMS & DIAGNOSTICS:[/bold red]\n")
+            for diag in report.problems:
+                sym = SYM_ERR if diag.is_error else SYM_WARN
+                self.console.print(f"{sym} [bold underline]{diag.title}[/bold underline]\n")
+
+                if diag.message:
+                    self.console.print(f"[bold]PROBLEM:[/bold]\n{diag.message}\n")
+
+                if diag.why:
+                    self.console.print(f"[bold]WHY:[/bold]\n{diag.why}\n")
+
+                if diag.evidence:
+                    self.console.print(f"[bold]EVIDENCE:[/bold]\n{diag.evidence}\n")
+
+                if diag.fix:
+                    self.console.print(f"[bold]SAFE FIX:[/bold]\n{diag.fix}\n")
+
+                if diag.command:
+                    self.console.print(f"[bold]COMMAND:[/bold]\n{diag.command}\n")
+
+                conf = diag.confidence.value if hasattr(diag.confidence, "value") else str(diag.confidence)
+                self.console.print(f"Confidence: [cyan]{conf}[/cyan]\n")
+                self.console.print(f"{SYM_DIV * 2}\n")
+
+        # Score & Summary
+        score = report.score
+        score_color = "green" if score >= 90 else ("yellow" if score >= 70 else "red")
+        self.console.print(f"[bold {score_color}]Health Score: {score}/100[/bold {score_color}] ({report.total_problems} problems found)")
+
+    def render_json(self, report: DiagnosticReport) -> str:
+        """Return JSON representation of the diagnostic report."""
+        return json.dumps(report.to_dict(), indent=2)
+
+    def render_markdown(self, report: DiagnosticReport) -> str:
+        """Render a GitHub-flavored Markdown diagnostic report."""
+        lines = [
+            f"# DevDoctor Diagnostic Report",
+            f"",
+            f"- **Target**: `{report.project_path}`",
+            f"- **Timestamp**: `{report.timestamp.isoformat()}`",
+            f"- **Health Score**: **{report.score}/100**",
+            f"- **Problems Found**: {report.total_problems} ({len(report.errors)} errors, {len(report.warnings)} warnings)",
+            f"- **Project Profile**: {report.project_info.summary_stack}",
+            f"",
+            f"---",
+            f"",
+            f"## Identified Problems",
+            f"",
+        ]
+
+        if not report.problems:
+            lines.append("All checks passed successfully! Machine and project are in a healthy state.")
+        else:
+            for diag in report.problems:
+                icon = "❌" if diag.is_error else "⚠️"
+                lines.append(f"### {icon} {diag.title}")
+                lines.append(f"")
+                lines.append(f"**Problem**: {diag.message}")
+                if diag.why:
+                    lines.append(f"")
+                    lines.append(f"> **Why**: {diag.why}")
+                if diag.evidence:
+                    lines.append(f"")
+                    lines.append(f"```\n{diag.evidence}\n```")
+                if diag.fix:
+                    lines.append(f"")
+                    lines.append(f"**Recommended Fix**:")
+                    lines.append(f"```bash\n{diag.command or diag.fix}\n```")
+                lines.append(f"")
+                lines.append(f"*Confidence: {diag.confidence.value}*")
+                lines.append(f"")
+                lines.append("---")
+                lines.append("")
+
+        lines.append("## Passed Checks")
+        lines.append("")
+        for diag in report.passed:
+            lines.append(f"- ✓ **{diag.title}**: {diag.message}")
+
+        return "\n".join(lines)

devdoctor/scanner.py

@@ -0,0 +1,98 @@
+"""Scanner engine: coordinates project detection, check execution, and report generation."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import List, Optional, Set
+
+from devdoctor.checks import get_registered_checks
+from devdoctor.models import Diagnostic, DiagnosticReport, ScanContext, Severity
+from devdoctor.plugin import discover_all_checks
+from devdoctor.project import detect_project
+from devdoctor.utils.platform_info import get_python_version_str, is_in_virtualenv
+
+
+class Scanner:
+    """Core diagnostic scanner for DevDoctor."""
+
+    def __init__(self, project_path: Optional[Path] = None, custom_checks_dir: Optional[Path] = None):
+        self.project_path = (project_path or Path.cwd()).resolve()
+        self.custom_checks_dir = custom_checks_dir
+
+    def create_context(self) -> ScanContext:
+        """Create and populate the ScanContext for this project."""
+        project_info = detect_project(self.project_path)
+        return ScanContext(
+            project_path=self.project_path,
+            is_venv=is_in_virtualenv(),
+            python_version=get_python_version_str(),
+            project_info=project_info,
+        )
+
+    def scan(
+        self,
+        categories: Optional[Set[str]] = None,
+        check_names: Optional[Set[str]] = None,
+        include_frameworks: bool = True,
+    ) -> DiagnosticReport:
+        """Run all diagnostic checks against the target project and produce a report."""
+        start_time = time.perf_counter()
+
+        context = self.create_context()
+        all_checks = discover_all_checks(self.project_path, self.custom_checks_dir)
+
+        diagnostics: List[Diagnostic] = []
+
+        for chk in all_checks:
+            # Check name filter
+            if check_names and chk.name not in check_names:
+                continue
+
+            # Category filter
+            if categories and chk.category not in categories:
+                continue
+
+            # Framework checks: only run automatically if the technology is detected in the project
+            # or if explicitly requested via check_names / category
+            if chk.category == "framework" and not check_names and not categories:
+                if not include_frameworks:
+                    continue
+                # If framework not detected in project_info, skip
+                if chk.name == "django" and ("Django" not in (context.project_info.frameworks if context.project_info else [])):
+                    continue
+                if chk.name == "fastapi" and ("FastAPI" not in (context.project_info.frameworks if context.project_info else [])):
+                    continue
+                if chk.name == "docker" and ("Docker" not in (context.project_info.technologies if context.project_info else [])):
+                    continue
+                if chk.name == "postgres" and ("PostgreSQL" not in (context.project_info.technologies if context.project_info else [])):
+                    continue
+                if chk.name == "redis" and ("Redis" not in (context.project_info.technologies if context.project_info else [])):
+                    continue
+
+            try:
+                result = chk.run(context)
+                if result is None:
+                    continue
+                elif isinstance(result, list):
+                    diagnostics.extend(result)
+                elif isinstance(result, Diagnostic):
+                    diagnostics.append(result)
+            except Exception as e:
+                # Fallback diagnostic if check throws an unexpected error
+                diagnostics.append(Diagnostic(
+                    title=f"Check '{chk.name}' failed to run",
+                    severity=Severity.WARNING,
+                    message=f"Internal check error: {e}",
+                    why=f"An exception occurred inside the check runner for {chk.name}.",
+                    check_id=f"error_{chk.name}",
+                ))
+
+        duration_ms = (time.perf_counter() - start_time) * 1000
+
+        return DiagnosticReport(
+            project_path=self.project_path,
+            project_info=context.project_info,
+            diagnostics=diagnostics,
+            duration_ms=duration_ms,
+        )

devdoctor/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility helpers for DevDoctor."""