jordan-devguard 0.1.0__tar.gz

jordan_devguard-0.1.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: jordan-devguard
+Version: 0.1.0
+Summary: Local-first security assistant for developers
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rich>=13.0
+Requires-Dist: packaging>=23.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"

jordan_devguard-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jordan-devguard"
+version = "0.1.0"
+description = "Local-first security assistant for developers"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+dependencies = [
+    "typer>=0.12",
+    "pydantic>=2.0",
+    "rich>=13.0",
+    "packaging>=23.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "ruff",
+    "black",
+    "mypy"
+]
+
+[project.scripts]
+devguard = "devguard.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.black]
+line-length = 100

jordan_devguard-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jordan_devguard-0.1.0/src/devguard/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

jordan_devguard-0.1.0/src/devguard/cli.py

@@ -0,0 +1,166 @@
+"""Interface en ligne de commande DevGuard."""
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+from pathlib import Path
+import sys
+import io
+
+# Forcer l'encodage UTF-8 sur Windows
+if sys.platform == "win32":
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+from devguard.core.scanner import SecurityScanner
+from devguard import __version__
+
+app = typer.Typer(
+    name="devguard",
+    help="Local-first security assistant for developers.",
+    no_args_is_help=True
+)
+console = Console()
+
+
+def calculate_score(findings) -> int:
+    """Calcule le score de securite sur 100."""
+    weights = {
+        "CRITICAL": 20,
+        "HIGH": 10,
+        "MEDIUM": 5,
+        "LOW": 2,
+        "INFO": 0
+    }
+    
+    score = 100
+    for finding in findings:
+        score -= weights.get(finding.severity, 0)
+    
+    return max(0, min(100, score))
+
+
+def generate_html_report(findings, project_path, score, output_path):
+    """Genere un rapport HTML."""
+    from devguard.report.html import HTMLReporter
+    reporter = HTMLReporter(findings, project_path, score)
+    reporter.generate(output_path)
+
+
+def display_results(findings, score, path):
+    """Affiche les resultats dans le terminal."""
+    table = Table(
+        title=f"Security Scan Results ({len(findings)} issues)",
+        box=box.ROUNDED,
+        title_style="bold red" if any(f.severity == "CRITICAL" for f in findings) else "bold yellow"
+    )
+    
+    table.add_column("Severity", style="bold", width=10)
+    table.add_column("Rule", style="cyan", width=15)
+    table.add_column("Description", width=35)
+    table.add_column("File", width=25)
+    table.add_column("Line", width=8, justify="right")
+    
+    for finding in findings:
+        severity_style = {
+            "CRITICAL": "red bold",
+            "HIGH": "red",
+            "MEDIUM": "yellow",
+            "LOW": "blue",
+            "INFO": "white"
+        }.get(finding.severity, "white")
+        
+        table.add_row(
+            f"[{severity_style}]{finding.severity}[/{severity_style}]",
+            finding.rule_id,
+            finding.title[:35],
+            finding.file[:25],
+            str(finding.line) if finding.line else "-"
+        )
+    
+    console.print(table)
+    
+    score_color = "red" if score < 50 else "yellow" if score < 75 else "green"
+    console.print(Panel(
+        f"[bold]Security Score:[/bold] [{score_color}]{score}/100[/{score_color}]\n"
+        f"[dim]{len(findings)} issues found[/dim]",
+        border_style=score_color,
+        width=40
+    ))
+
+
+@app.command()
+def scan(
+    path: str = typer.Argument(".", help="Path to project to scan"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose mode"),
+    format: str = typer.Option("terminal", "--format", "-f", help="Output format: terminal, html"),
+    output: str = typer.Option("devguard-report.html", "--output", "-o", help="Output file path")
+):
+    """Scan a project for security issues."""
+    
+    console.print(f"\n>> Scanning: {path}\n")
+    
+    try:
+        scanner = SecurityScanner(path)
+        findings = scanner.scan()
+        project_types = scanner.get_project_types()
+        
+        if project_types:
+            console.print("[dim]Project types detected:[/dim]")
+            for pt in project_types:
+                console.print(f"  [green]+[/green] {pt}")
+            console.print("")
+        else:
+            console.print("[dim]No specific project type detected[/dim]\n")
+        
+        if verbose:
+            console.print("[dim]Verbose mode enabled[/dim]\n")
+        
+        # Calculer le score
+        score = calculate_score(findings)
+        
+        # Exporter en HTML si demande
+        if format.lower() == "html":
+            output_path = Path(output)
+            generate_html_report(findings, path, score, output_path)
+            console.print(f"[green]Rapport HTML genere : {output_path.absolute()}[/green]")
+            if not findings:
+                console.print("[green]No security issues found![/green]")
+                console.print(f"[green]Score: {score}/100[/green]")
+            else:
+                display_results(findings, score, path)
+            raise typer.Exit(code=0)
+        
+        # Affichage normal
+        if not findings:
+            console.print("[green]No security issues found![/green]")
+            console.print(f"[green]Score: {score}/100[/green]")
+            raise typer.Exit(code=0)
+        
+        display_results(findings, score, path)
+        
+        if any(f.severity == "CRITICAL" for f in findings):
+            console.print("\n[red bold]CRITICAL issues detected![/red bold]")
+            console.print("[dim]Review and fix immediately before deployment.[/dim]")
+        
+        raise typer.Exit(code=0)
+        
+    except FileNotFoundError as error:
+        console.print(f"[red]ERROR {error}[/red]")
+        raise typer.Exit(code=1)
+    except Exception as error:
+        console.print(f"[red]ERROR Unexpected error: {error}[/red]")
+        if verbose:
+            import traceback
+            console.print(traceback.format_exc())
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def version():
+    """Display DevGuard version."""
+    console.print(f"[bold cyan]DevGuard[/bold cyan] [green]v{__version__}[/green]")
+
+
+if __name__ == "__main__":
+    app()

jordan_devguard-0.1.0/src/devguard/core/detector.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from typing import List
+
+class ProjectDetector:
+    def __init__(self, project_path: str):
+        self.path = Path(project_path)
+    
+    def detect(self) -> List[str]:
+        types = []
+        
+        if (self.path / "manage.py").exists():
+            types.append("django")
+        elif (self.path / "settings.py").exists():
+            types.append("django")
+        
+        if (self.path / "requirements.txt").exists():
+            types.append("python")
+        elif (self.path / "pyproject.toml").exists():
+            types.append("python")
+        
+        if (self.path / "package.json").exists():
+            types.append("node")
+        
+        if (self.path / "Dockerfile").exists():
+            types.append("docker")
+        elif (self.path / "docker-compose.yml").exists():
+            types.append("docker")
+        
+        return types

jordan_devguard-0.1.0/src/devguard/core/finding.py

@@ -0,0 +1,20 @@
+from enum import Enum
+from pydantic import BaseModel
+
+
+class Severity(str, Enum):
+    CRITICAL = "CRITICAL"
+    HIGH = "HIGH"
+    MEDIUM = "MEDIUM"
+    LOW = "LOW"
+    INFO = "INFO"
+
+
+class Finding(BaseModel):
+    rule_id: str
+    severity: Severity
+    title: str
+    file: str
+    line: int | None = None
+    description: str
+    recommendation: str

jordan_devguard-0.1.0/src/devguard/core/scanner.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+from typing import List
+
+from devguard.core.finding import Finding
+from devguard.core.detector import ProjectDetector
+from devguard.scanners.secrets import SecretsScanner
+from devguard.scanners.django import DjangoScanner
+from devguard.scanners.docker import DockerScanner
+from devguard.scanners.dependencies import DependencyScanner
+
+class SecurityScanner:
+    def __init__(self, project_path: str):
+        self.path = Path(project_path)
+        self.project_types = ProjectDetector(project_path).detect()
+        
+        self.scanners = []
+        
+        # Secrets scanner - toujours actif
+        self.scanners.append(SecretsScanner(project_path))
+        
+        # Django scanner
+        django_scanner = DjangoScanner(project_path)
+        if django_scanner.is_applicable():
+            self.scanners.append(django_scanner)
+            if "django" not in self.project_types:
+                self.project_types.append("django")
+        
+        # Docker scanner
+        docker_scanner = DockerScanner(project_path)
+        if docker_scanner.is_applicable():
+            self.scanners.append(docker_scanner)
+            if "docker" not in self.project_types:
+                self.project_types.append("docker")
+        
+        # Dependency scanner
+        dep_scanner = DependencyScanner(project_path)
+        if dep_scanner.is_applicable():
+            self.scanners.append(dep_scanner)
+            if "dependencies" not in self.project_types:
+                self.project_types.append("dependencies")
+    
+    def scan(self) -> List[Finding]:
+        if not self.path.exists():
+            raise FileNotFoundError(f"Project not found: {self.path}")
+        
+        all_findings = []
+        
+        for scanner in self.scanners:
+            try:
+                findings = scanner.scan()
+                all_findings.extend(findings)
+            except Exception as e:
+                # Ignorer les erreurs d'un scanner, continuer avec les autres
+                pass
+        
+        return all_findings
+    
+    def get_project_types(self) -> List[str]:
+        return self.project_types

jordan_devguard-0.1.0/src/devguard/report/__init__.py

@@ -0,0 +1,4 @@
+"""Report generation module for DevGuard."""
+from devguard.report.html import HTMLReporter
+
+__all__ = ["HTMLReporter"]

jordan_devguard-0.1.0/src/devguard/report/html.py

@@ -0,0 +1,312 @@
+"""Generateur de rapport HTML pour DevGuard."""
+from pathlib import Path
+from datetime import datetime
+from typing import List
+
+from devguard.core.finding import Finding
+
+class HTMLReporter:
+    """Genere un rapport HTML des findings."""
+    
+    def __init__(self, findings: List[Finding], project_path: str, score: int):
+        self.findings = findings
+        self.project_path = Path(project_path)
+        self.score = score
+        self.timestamp = datetime.now()
+    
+    def generate(self, output_path: Path) -> None:
+        """Genere le rapport HTML."""
+        
+        # Compter les findings par severite
+        counts = {
+            "CRITICAL": 0,
+            "HIGH": 0,
+            "MEDIUM": 0,
+            "LOW": 0,
+            "INFO": 0
+        }
+        for f in self.findings:
+            if f.severity in counts:
+                counts[f.severity] += 1
+        
+        html = f"""
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DevGuard - Rapport de securite</title>
+    <style>
+        * {{
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }}
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #f5f7fa;
+            padding: 40px;
+            color: #2d3748;
+        }}
+        .container {{
+            max-width: 1200px;
+            margin: 0 auto;
+        }}
+        .header {{
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 40px;
+            border-radius: 12px;
+            margin-bottom: 30px;
+        }}
+        .header h1 {{
+            font-size: 32px;
+            margin-bottom: 10px;
+        }}
+        .header p {{
+            opacity: 0.9;
+            font-size: 16px;
+        }}
+        .score-card {{
+            background: white;
+            padding: 30px;
+            border-radius: 12px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+            margin-bottom: 30px;
+            text-align: center;
+        }}
+        .score-number {{
+            font-size: 72px;
+            font-weight: bold;
+            color: {self._get_score_color()};
+        }}
+        .score-label {{
+            font-size: 18px;
+            color: #718096;
+        }}
+        .score-grade {{
+            font-size: 24px;
+            font-weight: bold;
+            color: {self._get_score_color()};
+            margin-top: 10px;
+        }}
+        .stats {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }}
+        .stat-card {{
+            background: white;
+            padding: 20px;
+            border-radius: 12px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+            text-align: center;
+        }}
+        .stat-number {{
+            font-size: 32px;
+            font-weight: bold;
+        }}
+        .stat-label {{
+            font-size: 14px;
+            color: #718096;
+            margin-top: 5px;
+        }}
+        .stat-critical .stat-number {{ color: #e53e3e; }}
+        .stat-high .stat-number {{ color: #ed8936; }}
+        .stat-medium .stat-number {{ color: #ecc94b; }}
+        .stat-low .stat-number {{ color: #48bb78; }}
+        .findings-table {{
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+            overflow: hidden;
+        }}
+        .findings-table table {{
+            width: 100%;
+            border-collapse: collapse;
+        }}
+        .findings-table th {{
+            background: #f7fafc;
+            padding: 15px 20px;
+            text-align: left;
+            font-weight: 600;
+            color: #4a5568;
+            border-bottom: 2px solid #e2e8f0;
+        }}
+        .findings-table td {{
+            padding: 15px 20px;
+            border-bottom: 1px solid #e2e8f0;
+        }}
+        .findings-table tr:hover {{
+            background: #f7fafc;
+        }}
+        .severity-badge {{
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 20px;
+            font-size: 12px;
+            font-weight: bold;
+            text-transform: uppercase;
+        }}
+        .severity-CRITICAL {{ background: #fed7d7; color: #9b2c2c; }}
+        .severity-HIGH {{ background: #feebc8; color: #9c4221; }}
+        .severity-MEDIUM {{ background: #fefcbf; color: #975a16; }}
+        .severity-LOW {{ background: #c6f6d5; color: #276749; }}
+        .severity-INFO {{ background: #e2e8f0; color: #4a5568; }}
+        .recommendation {{
+            background: #ebf8ff;
+            padding: 10px 15px;
+            border-radius: 8px;
+            font-size: 14px;
+            color: #2b6cb0;
+            margin-top: 10px;
+        }}
+        .recommendation strong {{
+            color: #2c5282;
+        }}
+        .footer {{
+            text-align: center;
+            padding: 30px;
+            color: #a0aec0;
+            font-size: 14px;
+        }}
+        .project-info {{
+            background: white;
+            padding: 20px 30px;
+            border-radius: 12px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
+            margin-bottom: 30px;
+        }}
+        .project-info p {{
+            margin: 5px 0;
+            color: #4a5568;
+        }}
+        .project-info strong {{
+            color: #2d3748;
+        }}
+        @media (max-width: 768px) {{
+            body {{ padding: 20px; }}
+            .header {{ padding: 20px; }}
+            .stats {{ grid-template-columns: repeat(2, 1fr); }}
+            .findings-table {{
+                overflow-x: auto;
+            }}
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <div class="header">
+            <h1>DevGuard - Rapport de securite</h1>
+            <p>Analyse de securite automatisee pour developpeurs</p>
+        </div>
+        
+        <!-- Project Info -->
+        <div class="project-info">
+            <p><strong>Projet :</strong> {self.project_path.absolute()}</p>
+            <p><strong>Date :</strong> {self.timestamp.strftime('%d/%m/%Y a %H:%M')}</p>
+            <p><strong>Total :</strong> {len(self.findings)} probleme(s) detecte(s)</p>
+        </div>
+        
+        <!-- Score -->
+        <div class="score-card">
+            <div class="score-number">{self.score}</div>
+            <div class="score-label">Score de securite</div>
+            <div class="score-grade">{self._get_grade()}</div>
+        </div>
+        
+        <!-- Stats -->
+        <div class="stats">
+            <div class="stat-card stat-critical">
+                <div class="stat-number">{counts['CRITICAL']}</div>
+                <div class="stat-label">Critique</div>
+            </div>
+            <div class="stat-card stat-high">
+                <div class="stat-number">{counts['HIGH']}</div>
+                <div class="stat-label">Eleve</div>
+            </div>
+            <div class="stat-card stat-medium">
+                <div class="stat-number">{counts['MEDIUM']}</div>
+                <div class="stat-label">Moyen</div>
+            </div>
+            <div class="stat-card stat-low">
+                <div class="stat-number">{counts['LOW']}</div>
+                <div class="stat-label">Faible</div>
+            </div>
+        </div>
+        
+        <!-- Findings Table -->
+        <div class="findings-table">
+            <h3 style="padding: 20px; font-size: 18px;">Detail des problemes</h3>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Severite</th>
+                        <th>Regle</th>
+                        <th>Description</th>
+                        <th>Fichier</th>
+                        <th>Ligne</th>
+                    </tr>
+                </thead>
+                <tbody>
+        """
+        
+        for finding in self.findings:
+            html += f"""
+                    <tr>
+                        <td><span class="severity-badge severity-{finding.severity}">{finding.severity}</span></td>
+                        <td><code style="background: #f0f0f0; padding: 2px 8px; border-radius: 4px; font-size: 13px;">{finding.rule_id}</code></td>
+                        <td>
+                            <div style="font-weight: 500;">{finding.title}</div>
+                            <div style="font-size: 13px; color: #718096; margin-top: 4px;">{finding.description[:150]}{'...' if len(finding.description) > 150 else ''}</div>
+                            <div class="recommendation">
+                                <strong>Recommandation :</strong> {finding.recommendation}
+                            </div>
+                        </td>
+                        <td style="font-size: 14px; color: #4a5568;">{finding.file}</td>
+                        <td style="text-align: center; font-weight: 500;">{finding.line if finding.line else '-'}</td>
+                    </tr>
+            """
+        
+        html += """
+                </tbody>
+            </table>
+        </div>
+        
+        <div class="footer">
+            <p>Genere par DevGuard v0.1.0</p>
+            <p style="margin-top: 5px;">Secure your code before you deploy it.</p>
+        </div>
+    </div>
+</body>
+</html>
+        """
+        
+        # Ecrire le fichier
+        output_path.write_text(html, encoding='utf-8')
+    
+    def _get_score_color(self) -> str:
+        """Retourne la couleur en fonction du score."""
+        if self.score >= 90:
+            return '#48bb78'  # Vert
+        elif self.score >= 75:
+            return '#ecc94b'  # Jaune
+        elif self.score >= 50:
+            return '#ed8936'  # Orange
+        else:
+            return '#e53e3e'  # Rouge
+    
+    def _get_grade(self) -> str:
+        """Retourne la mention en fonction du score."""
+        if self.score >= 90:
+            return 'Excellent'
+        elif self.score >= 75:
+            return 'Bon'
+        elif self.score >= 50:
+            return 'A ameliorer'
+        elif self.score >= 25:
+            return 'Critique'
+        else:
+            return 'Urgent'

jordan_devguard-0.1.0/src/devguard/scanners/__init__.py

@@ -0,0 +1,7 @@
+"""Scanners package for DevGuard."""
+from devguard.scanners.secrets import SecretsScanner
+from devguard.scanners.django import DjangoScanner
+from devguard.scanners.docker import DockerScanner
+from devguard.scanners.dependencies import DependencyScanner
+
+__all__ = ["SecretsScanner", "DjangoScanner", "DockerScanner", "DependencyScanner"]