syfscan 0.1.0__tar.gz

syfscan-0.1.0/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: syfscan
+Version: 0.1.0
+Summary: Détecteur de vulnérabilités de dépendances

syfscan-0.1.0/README.md

@@ -0,0 +1,155 @@
+# SyfScan
+
+> Dependency vulnerability scanner for Python projects — powered by [OSV.dev](https://osv.dev) and Claude AI.
+
+---
+
+## Overview
+
+SyfScan is a command-line tool that scans your `requirements.txt` against the [OSV.dev](https://osv.dev) vulnerability database. It displays a severity-ranked report directly in your terminal and optionally generates a plain-language security summary using Claude AI — making security accessible even to developers unfamiliar with CVEs.
+
+---
+
+## Features
+
+- 🔍 Scans all dependencies in `requirements.txt` against OSV.dev
+- 🎨 Color-coded terminal output ranked by severity
+- 🤖 AI-generated summary with risks, fixes, and recommendations via Claude
+- 📄 Export report to JSON, HTML, or PDF
+- ⚡ Fast and lightweight — no local database required
+
+---
+
+## Requirements
+
+- Python 3.12+
+- An Anthropic API key *(optional — only required for AI summary)*
+
+---
+
+## Installation
+
+```bash
+git clone https://github.com/yourname/syfscan
+cd syfscan
+pip install -e .
+```
+
+If you want the AI summary, create a `.env` file at the root of the project:
+
+```bash
+# .env
+ANTHROPIC_API_KEY=sk-ant-...
+```
+
+> ⚠️ Never commit your `.env` file. Add it to `.gitignore`.
+
+---
+
+## Usage
+
+```bash
+# Full scan with AI summary
+syfscan requirements.txt
+
+# Scan without AI summary
+syfscan requirements.txt --no-ai
+
+# Show only the N most critical vulnerabilities per package
+syfscan requirements.txt -xvuln 5
+
+# Export report to JSON
+syfscan requirements.txt --json
+
+# Export report to HTML
+syfscan requirements.txt --html
+
+# Export report to PDF
+syfscan requirements.txt --pdf
+```
+
+---
+
+## Options
+
+| Flag | Description |
+|---|---|
+| `--no-ai` | Disable Claude AI summary |
+| `-xvuln N` | Limit output to the N most critical vulnerabilities per package |
+| `--json` | Export report to `rapport.json` |
+| `--html` | Export report to `rapport.html` |
+| `--pdf` | Export report to `rapport.pdf` |
+
+---
+
+## Example output
+
+```
+ ███████╗██╗   ██╗███████╗███████╗ ██████╗ █████╗ ███╗   ██╗
+ ██╔════╝╚██╗ ██╔╝██╔════╝██╔════╝██╔════╝██╔══██╗████╗  ██║
+ ███████╗ ╚████╔╝ █████╗  ███████╗██║     ███████║██╔██╗ ██║
+ ╚════██║  ╚██╔╝  ██╔══╝  ╚════██║██║     ██╔══██║██║╚██╗██║
+ ███████║   ██║   ██║     ███████║╚██████╗██║  ██║██║ ╚████║
+ ╚══════╝   ╚═╝   ╚═╝     ╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝
+ v1.0 — Python dependency vulnerability scanner.
+
+> Fichier cible : requirements.txt
+
+> Scan numpy 2.2.2
+> Scan pillow 12.1.1
+...
+
+pillow 12.1.1 — 6 vulnérabilité(s)
+  > CVE-2026-42311 — OOB Write with Invalid PSD Tile Extents
+  > CVE-2026-40192 — FITS GZIP decompression bomb
+  > CVE-2026-42309 — Heap buffer overflow with nested list coordinates
+  > CVE-2026-42310 — PDF Parsing Trailer Infinite Loop (DoS)
+  > CVE-2026-42308 — Integer overflow when processing fonts
+
+────────────────── AI Summary ──────────────────
+
+🔧 How to Fix
+Upgrade Pillow from 12.1.1 to 12.2.0. Run pip install --upgrade Pillow.
+
+⚠️  Risks
+Attackers could achieve arbitrary code execution, denial of service,
+or full system compromise via malicious image or document files.
+
+🛡️  Additional Measures
+- Validate and sanitize all uploaded files before processing.
+- Run image workloads in a sandboxed environment.
+- Enable automated dependency scanning in your CI/CD pipeline.
+```
+
+---
+
+## Project structure
+
+```
+syfscan/
+├── syfscan/
+│   ├── cli.py
+│   └── __main__.py
+├── parsers/
+│   └── requirement.py
+├── scanner/
+│   └── osv.py
+├── output/
+│   ├── terminal.py
+│   ├── json.py
+│   ├── html.py
+│   └── pdf.py
+├── ia/
+│   └── claude_summarizer.py
+├── test/
+├── .env
+├── .gitignore
+├── pyproject.toml
+└── README.md
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

syfscan-0.1.0/ia/claude_summarizer.py

@@ -0,0 +1,121 @@
+# ia/claude_summarizer.py
+import anthropic
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.rule import Rule
+import os
+
+load_dotenv()
+
+client = anthropic.Anthropic()
+
+console = Console()
+
+
+def generate_summary(report):
+    vulnerabilities_text = build_vulnerabilities_text(report)
+
+    if not vulnerabilities_text:
+        return None
+
+    message = client.messages.create(
+        model="claude-opus-4-6",
+        max_tokens=400,
+        messages=[
+            {
+                "role": "user",
+                "content": f"""You are a security expert. Analyze these vulnerabilities and respond in exactly this format:
+
+HOW TO FIX
+[One paragraph. List every package to upgrade and to which version.]
+
+RISKS
+[One paragraph. What could concretely happen if left unpatched.]
+
+ADDITIONAL MEASURES
+[3 bullet points max. Practical extra steps the developer can take.]
+
+Vulnerabilities:
+{vulnerabilities_text}"""
+            }
+        ]
+    )
+
+    return message.content[0].text
+
+
+def display_summary(ai_text):
+    sections = {
+        "HOW TO FIX":          ("🔧 How to Fix",          "green"),
+        "RISKS":               ("⚠️  Risks",               "red"),
+        "ADDITIONAL MEASURES": ("🛡️  Additional Measures", "yellow"),
+    }
+
+    console.print()
+    console.rule("[bold]AI Summary[/bold]")
+    console.print()
+
+    current_section = None
+    current_lines = []
+
+    for line in ai_text.splitlines():
+        line = line.strip()
+
+        matched = False
+        for key in sections:
+            if key in line.upper():
+                if current_section and current_lines:
+                    title, color = sections[current_section]
+                    content = "\n".join(current_lines).strip()
+                    console.print(f"[bold {color}]{title}[/bold {color}]")
+                    console.print(content)
+                    console.print()
+
+                current_section = key
+                current_lines = []
+                matched = True
+                break
+
+        if not matched and line:
+            current_lines.append(line)
+
+    # Flush last section
+    if current_section and current_lines:
+        title, color = sections[current_section]
+        content = "\n".join(current_lines).strip()
+        console.print(f"[bold {color}]{title}[/bold {color}]")
+        console.print(content)
+        console.print()
+
+
+def get_fixed_version(vuln):
+    try:
+        for affected in vuln.get("affected", []):
+            for r in affected.get("ranges", []):
+                for event in r.get("events", []):
+                    if "fixed" in event:
+                        return event["fixed"]
+    except (KeyError, IndexError):
+        pass
+    return None
+
+
+def build_vulnerabilities_text(report):
+    lines = []
+
+    for dep in report:
+        if not dep["vulnerabilites"]:
+            continue
+        for vuln in dep["vulnerabilites"]:
+            fixed = get_fixed_version(vuln)
+            severity = vuln.get("database_specific", {}).get("severity", "UNKNOWN")
+            line = (
+                f"- {dep['nom']} {dep['version']} : "
+                f"{vuln.get('id', 'UNKNOWN')} | "
+                f"{vuln.get('summary', 'No description')} | "
+                f"Severity: {severity} | "
+                f"Fixed in: {fixed or 'unknown'}"
+            )
+            lines.append(line)
+
+    return "\n".join(lines)

syfscan-0.1.0/output/html.py

@@ -0,0 +1,96 @@
+import json
+from .terminal import get_label, get_score, score_couleur
+
+# Aide IA pour cette fonction car orange3 n'existe pas en HTML, et orange n'offre pas le bon affichage au niveau du terminal
+def convert_couleur_html(couleur):
+    map = {
+        "red":"red",
+        "yellow":"gold",
+        "orange3":"orange"
+    }
+    return map.get(couleur, "black")
+
+def rapport_html (rapport, output_path, max_vulns):
+    
+#https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_span
+#https://www-sololearn-com.translate.goog/en/Discuss/2715062/how-to-code-html-in-python?_x_tr_sl=en&_x_tr_tl=fr&_x_tr_hl=fr&_x_tr_pto=rq#
+
+    html="""
+         <!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset ="UTF-8">
+                   <style>
+                   
+                   body {
+                   background-color: white;
+                   font-family: arial;
+                   }
+                   h1{
+                   color: black
+                   }
+                   h2{
+                   color: darkred
+                   }
+                   p{
+                   color: black
+                   }
+                   </style>
+                </head>
+                <body>
+                <h1>Rapport syfscan </h1>
+                   """
+
+
+
+    for dep in rapport:
+        nom = dep["nom"]
+        version = dep["version"]
+        vulns = dep["vulnerabilites"]
+
+        if max_vulns is not None:
+            vulns = vulns[:max_vulns]
+        couleur_h2 = "green" if not vulns else"darkred"
+
+        html+=f"<h2 style='color:{couleur_h2}'>{nom} {version}</h2>"
+
+        if not vulns:
+            html+=f"<p>Aucune vulnérabilité détectée</p>"
+            continue
+ 
+        
+        html+=f"<p>{len(vulns)} vulnérabilités détectées"
+        for v in vulns:
+
+            score = get_score(v)
+            couleur = convert_couleur_html(score_couleur(score))
+            cve = get_label(v)
+            summary = v.get("summary", "no description")
+            
+            html+=f"""  
+            <p>
+            <span style="color:{couleur}; font-weight:bold">{cve}
+            </span>
+            > Score: {score} <br>
+            {summary}
+            </p>
+            """
+
+        
+        
+    html+="""
+    </body>
+    </html>
+    
+"""
+
+    with open(output_path, "w", encoding="utf-8") as f :
+        f.write(html)
+        
+
+
+
+
+
+
+

syfscan-0.1.0/output/json.py

@@ -0,0 +1,57 @@
+import json
+from .terminal import get_label, get_score, score_couleur
+
+def rapport_json (rapport, output_path, max_vulns):
+    
+    results =[]
+
+    for dep in rapport:
+        nom = dep["nom"]
+        version = dep["version"]
+        vulns = dep["vulnerabilites"]
+
+        if max_vulns is not None:
+            vulns = vulns[:max_vulns]
+
+        if not vulns:
+            results.append({
+                "nom": nom,
+                "version": version,
+                "statut" : "non vulnerable",
+                "nombre de vulnerabilite(s)": 0,
+
+            },)
+            continue
+ 
+        vulns_list=[]
+
+        for v in vulns:
+
+            score = get_score(v)
+            couleur = score_couleur(score)
+            cve = get_label(v)
+            summary = v.get("summary", "no description")
+            vulns_list.append({
+                "score": score,
+                "cve": cve,
+                "summary": summary,
+            },)
+        
+        results.append({
+            "nom": nom,
+            "version": version,
+            "statut" : "vulnerable",
+            "nombre de vulnerabilite(s)": len(vulns),
+            "vulnerabilites": vulns_list
+        },)
+
+    with open(output_path, "w") as f :
+        json.dump(results, f, indent=4)         #conversion en json de la liste results
+        
+
+
+
+
+
+
+

syfscan-0.1.0/output/pdf.py

@@ -0,0 +1,74 @@
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from reportlab.lib import colors
+from .terminal import get_label, get_score, score_couleur
+def rapport_pdf(rapport, output_path, max_vulns=None):
+    c = canvas.Canvas(str(output_path), pagesize=letter)
+    width, height = letter
+
+    y = height - 40
+
+    c.setFont("Helvetica-Bold", 14)
+    c.drawString(40, y, "Rapport SyfScan - Vulnérabilités")
+
+    y -= 30
+
+    c.setFont("Helvetica", 10)
+
+    for dep in rapport:
+        nom = dep.get("nom")
+        version = dep.get("version")
+        vulns = dep.get("vulnerabilites", [])
+
+        if max_vulns:
+            vulns = vulns[:max_vulns]
+        if not vulns :
+            c.setFillColor(colors.green)
+        else:
+            c.setFillColor(colors.red)
+        
+
+        c.setFont("Helvetica-Bold", 11)
+        c.drawString(40, y, f"{nom} ({version})")
+        y -= 15
+
+        if not vulns:
+            
+            c.setFont("Helvetica", 10)
+            c.drawString(60, y, "Non vulnérable")
+            y -= 20
+            continue
+        
+
+
+        
+        c.setFont("Helvetica", 10)
+        c.drawString(60, y, f"{len(vulns)} vulnérabilité(s)")
+        y -= 15
+
+        for v in vulns:
+            #cve = v.get("id", "N/A")
+            cve=get_label(v)
+            summary = v.get("summary", "no description")
+            score = get_score(v)
+            couleur = score_couleur(score)
+            text = f"- {cve}: {summary[:60]}"
+
+            if couleur =="red":
+                c.setFillColor(colors.red)
+            elif couleur =="orange3":
+                c.setFillColor(colors.orange)
+            else:
+                c.setFillColor(colors.gold)
+
+            if y < 40:
+                c.showPage()
+                c.setFont("Helvetica", 10)
+                y = height - 40
+
+            c.drawString(80, y, text)
+            y -= 15
+
+        y -= 10
+
+    c.save()

syfscan-0.1.0/output/terminal.py

@@ -0,0 +1,72 @@
+from rich.console import Console
+
+console = Console()
+
+# https://ossf.github.io/osv-schema/#database_specific-field
+def get_score(vuln):
+    # Si on a le score dans severity[]
+    for severity in vuln.get("severity", []):
+        if severity.get("type") in ("CVSS_V3", "CVSS_V2"):
+            try:
+                return float(severity.get("score", 0.0))
+            except ValueError:
+                pass
+
+    score_dictionnary = {"CRITICAL": 9.5, "HIGH": 8.0, "MEDIUM": 5.0, "LOW": 2.0}
+
+    # Si le score est dans database_specific
+    db_severity = vuln.get("database_specific", {}).get("severity", "")
+    if db_severity.upper() in score_dictionnary:
+        return score_dictionnary[db_severity.upper()]
+
+    # Si le score est dans affected[0].ecosystem_specific
+    affected = vuln.get("affected", [])
+    if affected:
+        eco_severity = affected[0].get("ecosystem_specific", {}).get("severity", "")
+        if eco_severity.upper() in score_dictionnary:
+            return score_dictionnary[eco_sev.upper()]
+
+    return 0.0
+
+
+def score_couleur(score):
+    if score >= 9.0:
+        return "red"
+    elif score >= 7.0:
+        return "orange3"
+    else:
+        return "yellow"
+
+
+# Fonction faite avec IA
+def get_label(vuln):
+    aliases = vuln.get("aliases", [])
+    return next((a for a in aliases if a.startswith("CVE-")), vuln.get("id", "N/A"))
+
+
+def display_report(rapport, max_vulns=None):
+    console.print("\n[bold green]// Rapport syfscan[/bold green]\n")
+
+    for dep in rapport:
+        nom = dep["nom"]
+        version = dep["version"]
+        vulns = dep["vulnerabilites"]
+
+        if max_vulns is not None:
+            vulns = vulns[:max_vulns]
+
+        if not vulns:
+            console.print(f"[green]{nom} {version} — 0 vulnérabilité[/green]")
+            console.print()
+            continue
+
+        console.print(f"[red]{nom} {version} — {len(vulns)} vulnérabilité(s)[/red]")
+
+        for v in vulns:
+            score = get_score(v)
+            couleur = score_couleur(score)
+            cve = get_label(v)
+            summary = v.get("summary", "no description")
+            console.print(f"  [dim]>[/dim] [{couleur}]{cve} — {summary}[/{couleur}]")
+
+        console.print()

syfscan-0.1.0/parsers/requirement.py

@@ -0,0 +1,41 @@
+from packaging.requirements import Requirement
+from rich.console import Console
+
+console = Console()
+
+def parse_requirements(fichier):
+    finale_liste =[]
+    try :
+        with open (fichier, "r") as f :
+            lignes = f.readlines()
+            
+            for ligne in lignes :
+                ligne = ligne.strip()
+
+                if not ligne or ligne.startswith('#'):
+                    continue
+                
+                try :
+                    req = Requirement(ligne)
+                    nom = req.name
+                    version ="0.0.0"
+
+                    if req.specifier :#determiner la bonne version si elle existe (borne basse)
+                        for spec in req.specifier :
+                            if spec.operator in ["==", ">=", "~=", "==="]:
+                                version =spec.version
+                                break
+                    finale_liste.append({"nom":nom, "version" :version})
+                
+                except Exception :
+                    console.print(f"[yellow][ WARNING ][/yellow] [dim]Ligne ignorée —[/dim] [cyan]{ligne}[/cyan]")
+
+                        
+                    
+
+    except Exception as e :
+                    console.print(f"[bold red][ ERROR ][/bold red] [red]impossible de lire le fichier — {e}[/red]")
+                    cons
+
+    console.print()
+    return finale_liste

syfscan-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+# https://www.reddit.com/r/learnpython/comments/182cdyz/how_can_i_create_a_command_line_tool_and_execute/
+# https://ycopin.pages.in2p3.fr/Informatique-Python/Cours/packaging.html
+
+[project]
+name = "syfscan"
+description = "Détecteur de vulnérabilités de dépendances"             
+version = "0.1.0"
+
+[project.scripts]
+syfscan = "syfscan.__main__:main"
+
+[tool.setuptools.packages]               
+find = {} 
+
+
+

syfscan-0.1.0/scanner/osv.py

@@ -0,0 +1,48 @@
+import requests
+from rich.console import Console
+
+from output.terminal import get_score
+
+console = Console()
+
+OSV_API_URL = "https://api.osv.dev/v1/query"
+
+def scan_dependencies(dependencies):
+ 
+    rapport = []
+
+    for dep in dependencies:
+        nom = dep["nom"]
+        version = dep["version"]
+
+        console.print(f"[green]>[/green] [dim]Scan[/dim] [cyan]{nom}[/cyan] [dim]{version}[/dim]")
+
+        try:
+            response = requests.post(OSV_API_URL, json={
+                "package": {
+                    "name": nom,
+                    "ecosystem": "PyPI"
+                },
+                "version": version
+            })
+            response.raise_for_status()
+            data = response.json()
+
+            vulns = sorted(data.get("vulns", []), key=get_score, reverse=True)
+
+            rapport.append({
+                "nom": nom,
+                "version": version,
+                "vulnerabilites": vulns
+            })
+
+        except requests.exceptions.RequestException as e:
+            console.print(f"[bold red][ ERROR ][/bold red] [red]{nom} — {e}[/red]")            
+            rapport.append({
+                "nom": nom,
+                "version": version,
+                "vulnerabilites": [],
+                "erreur": str(e)
+            })
+
+    return rapport

syfscan-0.1.0/setup.cfg

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

syfscan-0.1.0/syfscan/__main__.py

@@ -0,0 +1,4 @@
+from syfscan.cli import main
+
+if __name__== "__main__":
+    main()

syfscan-0.1.0/syfscan/cli.py

@@ -0,0 +1,120 @@
+import argparse
+import sys
+from pathlib import Path
+from rich.console import Console
+
+from parsers.requirement import parse_requirements
+from scanner.osv import scan_dependencies
+from ia.claude_summarizer import generate_summary, display_summary
+from output.terminal import display_report
+from output.json import rapport_json 
+from output.html import rapport_html
+from output.pdf import rapport_pdf
+
+console = Console()
+
+BANNER = """
+[green]
+ ███████╗██╗   ██╗███████╗███████╗ ██████╗ █████╗ ███╗   ██╗
+ ██╔════╝╚██╗ ██╔╝██╔════╝██╔════╝██╔════╝██╔══██╗████╗  ██║
+ ███████╗ ╚████╔╝ █████╗  ███████╗██║     ███████║██╔██╗ ██║
+ ╚════██║  ╚██╔╝  ██╔══╝  ╚════██║██║     ██╔══██║██║╚██╗██║
+ ███████║   ██║   ██║     ███████║╚██████╗██║  ██║██║ ╚████║
+ ╚══════╝   ╚═╝   ╚═╝     ╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝
+[/green][dim green] v1.0 — Python dependency vulnerability scanner. [/dim green]
+"""
+
+def main():
+    # Fait avec https://docs.python.org/3/library/argparse.html
+    parser = argparse.ArgumentParser(
+        prog="syfscan",
+        description="SyfScan — Détecteur de vulnérabilités de dépendances",
+        epilog="Exemple : syfscan requirements.txt"
+    )
+
+    parser.add_argument(
+        "file",
+        help="Chemin vers le fichier requirements.txt"
+    )
+
+    parser.add_argument(
+        "-xvuln",
+        type=int,
+        default=None,
+        metavar="X",
+        help="Afficher uniquement les X vulnérabilités les plus graves (ex: -xvuln 5)"
+    )
+
+    parser.add_argument(
+        "--no-ai",
+        action="store_true",
+        help="Désactiver le résumé IA"
+    )
+
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Générer un fichier au format JSON"
+    )
+
+    parser.add_argument(
+        "--html",
+        action="store_true",
+        help="Générer un fichier au format HTML"
+    )
+
+    parser.add_argument(
+        "--pdf",
+        action="store_true",
+        help="Générer un fichier au format PDF"
+    )
+
+
+    args = parser.parse_args()
+    file = Path(args.file)
+
+    console.print(BANNER)
+
+    # Verification validité des entrées clients
+    if not file.exists():
+        console.print(f"[bold red][ERREUR][/bold red] Fichier '{file}' introuvable.")
+        sys.exit(1)
+    
+
+
+    if file.name != "requirements.txt":
+        console.print("[bold red][ERREUR][/bold red] SyfScan accepte uniquement les fichiers requirements.txt")    
+        sys.exit(1)
+
+    #  Parsing
+    console.print(f"[green]>[/green] [dim]Fichier cible :[/dim][cyan]{file}[/cyan]")
+    dependencies = parse_requirements(file) # fonction parse à récupérer dans parser/requirements.py
+
+
+    #  Interrogation OSV.dev 
+    report = scan_dependencies(dependencies) # fonction scan_dependencies à récupérer dans scanner/osv.py 
+
+    #  Output 
+
+      #permet de choisir sous quel format exporter les données, par defaut dans le terminal
+    if args.json:
+        rapport_json(report, Path("rapport.json"), args.xvuln)
+        console.print("\n[bold green]Rapport JSON généré :[/bold green] rapport.json\n")
+    elif args.html:
+        rapport_html(report, Path("rapport.html"), args.xvuln)
+        console.print("\n[bold green]Rapport HTML généré :[/bold green] rapport.html\n")
+    elif args.pdf:
+        rapport_pdf(report, Path("rapport.pdf"), args.xvuln)
+        console.print("\n[bold green]Rapport PDF généré :[/bold green] rapport.pdf\n")
+    
+    else :
+        display_report(report, args.xvuln)
+
+        #  Résumé IA 
+    if not args.no_ai:
+        print("Generating AI summary...")
+        ai_report = generate_summary(report)
+        display_summary(ai_report)
+
+if __name__ == "__main__" :
+    main()

syfscan-0.1.0/syfscan.egg-info/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: syfscan
+Version: 0.1.0
+Summary: Détecteur de vulnérabilités de dépendances

syfscan-0.1.0/syfscan.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+ia/__init__.py
+ia/claude_summarizer.py
+output/__init__.py
+output/html.py
+output/json.py
+output/pdf.py
+output/terminal.py
+parsers/requirement.py
+scanner/__init__.py
+scanner/osv.py
+syfscan/__init__.py
+syfscan/__main__.py
+syfscan/cli.py
+syfscan.egg-info/PKG-INFO
+syfscan.egg-info/SOURCES.txt
+syfscan.egg-info/dependency_links.txt
+syfscan.egg-info/entry_points.txt
+syfscan.egg-info/top_level.txt

syfscan-0.1.0/syfscan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

syfscan-0.1.0/syfscan.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+syfscan = syfscan.__main__:main

syfscan-0.1.0/syfscan.egg-info/top_level.txt

@@ -0,0 +1,7 @@
+dist
+ia
+output
+parsers
+scanner
+syfscan
+test