shi-saash 0.3.0__tar.gz

shi_saash-0.3.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include src/shi/artifacts *
+recursive-include src/shi/datasets *.jsonl
+recursive-include src/shi/demo_repo *

shi_saash-0.3.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: shi-saash
+Version: 0.3.0
+Summary: SHI (SaaS H Intelligence) : diagnostic d'incidents logiciels en conseil seulement, avec masquage des secrets, preuves et journal d'audit.
+License: Proprietary
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Provides-Extra: api
+Requires-Dist: fastapi>=0.110; extra == "api"
+Requires-Dist: uvicorn>=0.27; extra == "api"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: httpx>=0.26; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+Requires-Dist: uvicorn>=0.27; extra == "dev"
+
+# shi-saash — SHI (SaaS H Intelligence), bibliothèque Python
+
+```bash
+pip install shi-saash-0.3.0-py3-none-any.whl     # ou, depuis les sources : pip install .
+```
+
+```python
+import shi
+
+r = shi.diagnose("Les clients ne peuvent plus payer", logs="ERROR stripe card_declined")
+r["category"]      # 'paiement'
+r["uncertain"]     # True si les preuves manquent
+r["hypotheses"]    # causes possibles, chacune avec ses preuves (ligne de journal)
+r["advice"]        # vérifications sûres, en lecture seule
+r["masked"]        # secrets masqués avant l'analyse
+
+shi.classify("Le disque est plein").label   # 'stockage'
+```
+
+Ligne de commande : `shi classify "texte"`, `shi-server` (service HTTP, variable `SHI_API_KEY`), `python -m shi ...`.
+Le modèle d'exemple est fourni dans le paquet. Pour utiliser votre propre modèle entraîné sans toucher au paquet :
+`SHI_HOME=/mon/dossier shi train-classifier`.
+`pip install "shi-saash[api]"` ajoute FastAPI pour l'API complète (`shi/api`).
+
+**Ce que la bibliothèque ne fait pas** : elle n'exécute aucune commande pour `diagnose`/`classify`, et ne remplace pas
+un humain. Voir « Limites connues » plus bas.
+
+**Vérification** : la structure du paquet a été vérifiée en construisant une roue, en l'installant dans un
+environnement propre puis en lançant les tests contre le paquet installé. Le fichier `pyproject.toml` n'a pas pu être
+compilé dans l'environnement de génération (outil `setuptools` incompatible) : lancez `pip install .` chez vous et
+signalez toute erreur.
+
+---
+
+# SHI — SaaS H Intelligence (v0.1)
+
+Implémentation de départ de l'architecture décrite dans le document technique SHI :
+**observer → comprendre → diagnostiquer → proposer → tester → agir → vérifier**.
+
+SHI n'est pas un chatbot : c'est une chaîne de composants (modèles d'IA minuscules + logiciels
+classiques déterministes) où **le modèle ne lance jamais de commande**. Tout passe par une garde
+de permissions, un exécuteur isolé et un journal d'audit.
+
+## Démarrage rapide
+
+```bash
+pip install numpy            # seul prérequis du cœur (OK sur Pydroid 3)
+pip install pytest fastapi uvicorn httpx   # optionnels : tests pytest + API
+
+python -m shi.cli build-dataset      # génère datasets/{train,val,test}.jsonl
+python -m shi.cli train-classifier    # SHI-0.2 : entraîne et évalue
+python -m shi.cli classify "Les pages chargent très lentement"
+python -m shi.cli train-transformer --steps 600   # SHI-0.3 : mini-Transformer
+python -m shi.cli generate "Le serveur"
+python -m shi.cli demo --approve      # cycle complet sur le dépôt de démonstration
+python -m shi.cli demo --auto         # même cycle en mode automatique
+
+python -m unittest discover -s tests -t .   # ou : pytest
+```
+
+API (nécessite FastAPI) :
+
+```bash
+export SHI_API_KEY="une-longue-clé-secrète"
+export SHI_ALLOWED_ROOTS="/chemin/vers/mes/dépôts"
+python -m shi.cli serve
+```
+
+## Service de diagnostic (conseil seulement)
+
+`shi-server` (variable `SHI_API_KEY`) démarre un petit serveur HTTP sans dépendance autre que NumPy :
+`POST /diagnose` renvoie catégorie, hypothèses avec preuves et pistes de vérification sûres. Voir `DEPLOIEMENT-RENDER.md`.
+Les 11 tests de `tests/test_diagnose_service.py` passent (serveur réel lancé et interrogé).
+
+## Ce qui est implémenté (phases du plan)
+
+| Phase | Module | Contenu |
+|---|---|---|
+| 1-2 | `app/models/classifier` | SHI-0.2 (corpus manuel `corpus_libre.py`, `corpus_extra.py`, lexique `lexicon.py`, essais dans `experiments/`) : tokenizer français, TF-IDF (mots, bigrammes, 4-grammes), régression softmax NumPy + Adam, arrêt anticipé, métriques (précision, rappel, matrice de confusion), sauvegarde |
+| 3 | `app/models/transformer` | SHI-0.3 : mini-Transformer caractère (attention causale, FFN, Adam), rétropropagation écrite à la main et **vérifiée par test de gradient numérique** |
+| 4 | `app/ingestion` | Masquage des secrets/PII (clés, JWT, mots de passe, e-mails, cartes validées Luhn) **avant** analyse ; normalisation des logs en événements |
+| 5 | `app/analysis`, `app/diagnosis`, `app/solutions`, `app/planner` | Faits vs hypothèses avec preuves ; analyse AST ; tracebacks → fichiers ; plusieurs solutions comparées (avantages, risques, score) ; correctifs candidats déterministes avec diff |
+| 6 | `app/sandbox` | Copie temporaire, environnement épuré, limites CPU/mémoire/durée/fichiers, groupe de processus tué au délai, réseau coupé si `unshare` est disponible, liens symboliques ignorés, commande unique validée |
+| 7 | `app/security`, `app/execution` | Mode manuel (diff → tests → approbation), garde de permissions, sauvegarde + retour arrière |
+| 8 | `app/execution` | Mode automatique limité aux actions pré-autorisées ; s'arrête si diagnostic incertain, tests en échec ou action sensible |
+| — | `app/audit`, `app/verification`, `app/reports` | Journal à chaînage de hachages ; verdict réussite / échec / incertain ; rapport Markdown |
+| — | `app/api` | Endpoints du document (+ `/auto`, `/rollback`, `/api/audit/verify`), clé d'API, dépôts limités aux dossiers autorisés |
+
+Correctifs automatiques disponibles : argument par défaut mutable, `except:` nu, `== None`,
+appels `requests` sans `timeout`.
+
+## Règles de sécurité appliquées
+
+- Lecture seule par défaut ; `APPLY_FIX` doit être accordé au projet. Une approbation humaine ne crée jamais une permission absente.
+- Aucune modification du dépôt réel sans tests isolés réussis ; sauvegarde avant, vérification après, retour arrière automatique si la vérification échoue.
+- Une action destructive ne peut jamais être automatique.
+- Le contenu du dépôt et des logs est **non fiable** : les instructions suspectes (README, commentaires, logs) sont signalées dans le rapport, jamais obéies.
+- Un fichier modifié depuis l'analyse invalide le correctif (empreinte SHA-256).
+- Le rapport ne déclare « résolu » que si les tests prouvent la correction ; un bug non reproduit donne « incertain ».
+
+## Limites connues (à lire)
+
+- **Précision du classificateur (v0.2.1)** : entraîné sur environ 420 phrases rédigées à la main, 12 catégories (10 d'incidents + `securite` + `inconnu` pour refuser les phrases hors sujet). Exactitude de **0,88** sur 60 phrases écrites à part et jamais utilisées pour entraîner ni régler (`datasets/test_final.jsonl`, 5 par catégorie). Précautions : un seul auteur et un seul style ; 60 phrases donnent une incertitude d'environ ±8 points ; ce n'est **pas** une mesure sur de vrais incidents. Historique mesuré : gabarits seuls 0,39 sur des phrases libres ; ajouter 264 phrases libres 0,51 ; ajouter 180 phrases + 60 phrases de développement 0,88. **La quantité et la variété des données comptent bien plus que le réglage du modèle** (régularisation, taux d'apprentissage, lexique de mots-clés : aucun gain sur le test final, le lexique `lexicon.py` est donc désactivé par défaut). Pour progresser : de vrais incidents anonymisés, de plusieurs auteurs.
+- **Mini-Transformer** : modèle minuscule (un bloc, caractères). Il génère du texte plausible mais approximatif ; ce n'est pas un réparateur.
+- **Isolation** : ce n'est pas un conteneur. Pour du code réellement hostile ou en production, exécuter le runner dans un conteneur/VM dédié (Docker rootless, gVisor, Firecracker) sans accès à la production. Le niveau d'isolation réellement obtenu (réseau coupé ou non) est écrit dans chaque résultat de test.
+- **Non réalisé** : connecteurs GitHub/logs réels, PostgreSQL, file Redis/Celery, interface Android, déploiement. Le stockage de l'API est en mémoire.
+- **Tests** : la suite complète passe en `unittest` (49 tests exécutés). Les 5 tests d'API sont ignorés si FastAPI/httpx sont absents ; l'API n'a donc pas été exécutée dans l'environnement de génération et doit être testée chez vous (`pip install fastapi httpx`, puis relancer les tests).
+- Les corrections ne sont validées que par les tests du dépôt : des tests faibles donnent une validation faible.
+
+## Organisation
+
+```
+app/            cœur de SHI (voir tableau)
+datasets/       train/val/test.jsonl (générés) + test_manuel.jsonl (phrases libres)
+demo_repo/      dépôt de démonstration avec un vrai bug (argument par défaut mutable)
+artifacts/      modèles entraînés (classifier/, transformer/)
+tests/          suite de tests
+```
+
+## Étapes suivantes
+
+1. Remplacer le jeu synthétique par de vrais incidents anonymisés ; refaire l'évaluation sur un jeu de test jamais utilisé.
+2. Connecteur GitHub en lecture (jetons à portée limitée), puis logs/métriques.
+3. Runner en conteneur ; PostgreSQL ; file de tâches ; revue de sécurité avant toute action en production.
+4. Application Android : écrans incidents, solutions, diff, approbation (elle appelle l'API ; aucun secret en clair sur le téléphone).

shi_saash-0.3.0/README.md

@@ -0,0 +1,125 @@
+# shi-saash — SHI (SaaS H Intelligence), bibliothèque Python
+
+```bash
+pip install shi-saash-0.3.0-py3-none-any.whl     # ou, depuis les sources : pip install .
+```
+
+```python
+import shi
+
+r = shi.diagnose("Les clients ne peuvent plus payer", logs="ERROR stripe card_declined")
+r["category"]      # 'paiement'
+r["uncertain"]     # True si les preuves manquent
+r["hypotheses"]    # causes possibles, chacune avec ses preuves (ligne de journal)
+r["advice"]        # vérifications sûres, en lecture seule
+r["masked"]        # secrets masqués avant l'analyse
+
+shi.classify("Le disque est plein").label   # 'stockage'
+```
+
+Ligne de commande : `shi classify "texte"`, `shi-server` (service HTTP, variable `SHI_API_KEY`), `python -m shi ...`.
+Le modèle d'exemple est fourni dans le paquet. Pour utiliser votre propre modèle entraîné sans toucher au paquet :
+`SHI_HOME=/mon/dossier shi train-classifier`.
+`pip install "shi-saash[api]"` ajoute FastAPI pour l'API complète (`shi/api`).
+
+**Ce que la bibliothèque ne fait pas** : elle n'exécute aucune commande pour `diagnose`/`classify`, et ne remplace pas
+un humain. Voir « Limites connues » plus bas.
+
+**Vérification** : la structure du paquet a été vérifiée en construisant une roue, en l'installant dans un
+environnement propre puis en lançant les tests contre le paquet installé. Le fichier `pyproject.toml` n'a pas pu être
+compilé dans l'environnement de génération (outil `setuptools` incompatible) : lancez `pip install .` chez vous et
+signalez toute erreur.
+
+---
+
+# SHI — SaaS H Intelligence (v0.1)
+
+Implémentation de départ de l'architecture décrite dans le document technique SHI :
+**observer → comprendre → diagnostiquer → proposer → tester → agir → vérifier**.
+
+SHI n'est pas un chatbot : c'est une chaîne de composants (modèles d'IA minuscules + logiciels
+classiques déterministes) où **le modèle ne lance jamais de commande**. Tout passe par une garde
+de permissions, un exécuteur isolé et un journal d'audit.
+
+## Démarrage rapide
+
+```bash
+pip install numpy            # seul prérequis du cœur (OK sur Pydroid 3)
+pip install pytest fastapi uvicorn httpx   # optionnels : tests pytest + API
+
+python -m shi.cli build-dataset      # génère datasets/{train,val,test}.jsonl
+python -m shi.cli train-classifier    # SHI-0.2 : entraîne et évalue
+python -m shi.cli classify "Les pages chargent très lentement"
+python -m shi.cli train-transformer --steps 600   # SHI-0.3 : mini-Transformer
+python -m shi.cli generate "Le serveur"
+python -m shi.cli demo --approve      # cycle complet sur le dépôt de démonstration
+python -m shi.cli demo --auto         # même cycle en mode automatique
+
+python -m unittest discover -s tests -t .   # ou : pytest
+```
+
+API (nécessite FastAPI) :
+
+```bash
+export SHI_API_KEY="une-longue-clé-secrète"
+export SHI_ALLOWED_ROOTS="/chemin/vers/mes/dépôts"
+python -m shi.cli serve
+```
+
+## Service de diagnostic (conseil seulement)
+
+`shi-server` (variable `SHI_API_KEY`) démarre un petit serveur HTTP sans dépendance autre que NumPy :
+`POST /diagnose` renvoie catégorie, hypothèses avec preuves et pistes de vérification sûres. Voir `DEPLOIEMENT-RENDER.md`.
+Les 11 tests de `tests/test_diagnose_service.py` passent (serveur réel lancé et interrogé).
+
+## Ce qui est implémenté (phases du plan)
+
+| Phase | Module | Contenu |
+|---|---|---|
+| 1-2 | `app/models/classifier` | SHI-0.2 (corpus manuel `corpus_libre.py`, `corpus_extra.py`, lexique `lexicon.py`, essais dans `experiments/`) : tokenizer français, TF-IDF (mots, bigrammes, 4-grammes), régression softmax NumPy + Adam, arrêt anticipé, métriques (précision, rappel, matrice de confusion), sauvegarde |
+| 3 | `app/models/transformer` | SHI-0.3 : mini-Transformer caractère (attention causale, FFN, Adam), rétropropagation écrite à la main et **vérifiée par test de gradient numérique** |
+| 4 | `app/ingestion` | Masquage des secrets/PII (clés, JWT, mots de passe, e-mails, cartes validées Luhn) **avant** analyse ; normalisation des logs en événements |
+| 5 | `app/analysis`, `app/diagnosis`, `app/solutions`, `app/planner` | Faits vs hypothèses avec preuves ; analyse AST ; tracebacks → fichiers ; plusieurs solutions comparées (avantages, risques, score) ; correctifs candidats déterministes avec diff |
+| 6 | `app/sandbox` | Copie temporaire, environnement épuré, limites CPU/mémoire/durée/fichiers, groupe de processus tué au délai, réseau coupé si `unshare` est disponible, liens symboliques ignorés, commande unique validée |
+| 7 | `app/security`, `app/execution` | Mode manuel (diff → tests → approbation), garde de permissions, sauvegarde + retour arrière |
+| 8 | `app/execution` | Mode automatique limité aux actions pré-autorisées ; s'arrête si diagnostic incertain, tests en échec ou action sensible |
+| — | `app/audit`, `app/verification`, `app/reports` | Journal à chaînage de hachages ; verdict réussite / échec / incertain ; rapport Markdown |
+| — | `app/api` | Endpoints du document (+ `/auto`, `/rollback`, `/api/audit/verify`), clé d'API, dépôts limités aux dossiers autorisés |
+
+Correctifs automatiques disponibles : argument par défaut mutable, `except:` nu, `== None`,
+appels `requests` sans `timeout`.
+
+## Règles de sécurité appliquées
+
+- Lecture seule par défaut ; `APPLY_FIX` doit être accordé au projet. Une approbation humaine ne crée jamais une permission absente.
+- Aucune modification du dépôt réel sans tests isolés réussis ; sauvegarde avant, vérification après, retour arrière automatique si la vérification échoue.
+- Une action destructive ne peut jamais être automatique.
+- Le contenu du dépôt et des logs est **non fiable** : les instructions suspectes (README, commentaires, logs) sont signalées dans le rapport, jamais obéies.
+- Un fichier modifié depuis l'analyse invalide le correctif (empreinte SHA-256).
+- Le rapport ne déclare « résolu » que si les tests prouvent la correction ; un bug non reproduit donne « incertain ».
+
+## Limites connues (à lire)
+
+- **Précision du classificateur (v0.2.1)** : entraîné sur environ 420 phrases rédigées à la main, 12 catégories (10 d'incidents + `securite` + `inconnu` pour refuser les phrases hors sujet). Exactitude de **0,88** sur 60 phrases écrites à part et jamais utilisées pour entraîner ni régler (`datasets/test_final.jsonl`, 5 par catégorie). Précautions : un seul auteur et un seul style ; 60 phrases donnent une incertitude d'environ ±8 points ; ce n'est **pas** une mesure sur de vrais incidents. Historique mesuré : gabarits seuls 0,39 sur des phrases libres ; ajouter 264 phrases libres 0,51 ; ajouter 180 phrases + 60 phrases de développement 0,88. **La quantité et la variété des données comptent bien plus que le réglage du modèle** (régularisation, taux d'apprentissage, lexique de mots-clés : aucun gain sur le test final, le lexique `lexicon.py` est donc désactivé par défaut). Pour progresser : de vrais incidents anonymisés, de plusieurs auteurs.
+- **Mini-Transformer** : modèle minuscule (un bloc, caractères). Il génère du texte plausible mais approximatif ; ce n'est pas un réparateur.
+- **Isolation** : ce n'est pas un conteneur. Pour du code réellement hostile ou en production, exécuter le runner dans un conteneur/VM dédié (Docker rootless, gVisor, Firecracker) sans accès à la production. Le niveau d'isolation réellement obtenu (réseau coupé ou non) est écrit dans chaque résultat de test.
+- **Non réalisé** : connecteurs GitHub/logs réels, PostgreSQL, file Redis/Celery, interface Android, déploiement. Le stockage de l'API est en mémoire.
+- **Tests** : la suite complète passe en `unittest` (49 tests exécutés). Les 5 tests d'API sont ignorés si FastAPI/httpx sont absents ; l'API n'a donc pas été exécutée dans l'environnement de génération et doit être testée chez vous (`pip install fastapi httpx`, puis relancer les tests).
+- Les corrections ne sont validées que par les tests du dépôt : des tests faibles donnent une validation faible.
+
+## Organisation
+
+```
+app/            cœur de SHI (voir tableau)
+datasets/       train/val/test.jsonl (générés) + test_manuel.jsonl (phrases libres)
+demo_repo/      dépôt de démonstration avec un vrai bug (argument par défaut mutable)
+artifacts/      modèles entraînés (classifier/, transformer/)
+tests/          suite de tests
+```
+
+## Étapes suivantes
+
+1. Remplacer le jeu synthétique par de vrais incidents anonymisés ; refaire l'évaluation sur un jeu de test jamais utilisé.
+2. Connecteur GitHub en lecture (jetons à portée limitée), puis logs/métriques.
+3. Runner en conteneur ; PostgreSQL ; file de tâches ; revue de sécurité avant toute action en production.
+4. Application Android : écrans incidents, solutions, diff, approbation (elle appelle l'API ; aucun secret en clair sur le téléphone).

shi_saash-0.3.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shi-saash"
+version = "0.3.0"
+description = "SHI (SaaS H Intelligence) : diagnostic d'incidents logiciels en conseil seulement, avec masquage des secrets, preuves et journal d'audit."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Proprietary" }
+dependencies = ["numpy>=1.24"]
+
+[project.optional-dependencies]
+api = ["fastapi>=0.110", "uvicorn>=0.27"]
+dev = ["pytest>=7.0", "httpx>=0.26", "fastapi>=0.110", "uvicorn>=0.27"]
+
+[project.scripts]
+shi = "shi.cli:main"
+shi-server = "shi.server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+shi = ["py.typed", "artifacts/**/*", "datasets/*.jsonl", "demo_repo/**/*"]

shi_saash-0.3.0/setup.cfg

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

shi_saash-0.3.0/src/shi/__init__.py

@@ -0,0 +1,45 @@
+"""SHI — SaaS H Intelligence : diagnostic d'incidents logiciels, en conseil seulement.
+
+Utilisation rapide ::
+
+    import shi
+    r = shi.diagnose("Les clients ne peuvent plus payer", logs="ERROR stripe card_declined")
+    print(r["category"], r["uncertain"])
+    for h in r["hypotheses"]: print(h["label"], h["confidence"], h["evidence"])
+    print(r["advice"])
+
+La bibliothèque n'exécute aucune commande et n'écrit rien sur votre système par défaut.
+Les secrets présents dans le texte sont masqués avant l'analyse.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+__version__ = "0.3.0"
+__all__ = ["diagnose", "classify", "load_classifier", "SHIClassifier", "__version__"]
+
+from shi.models.classifier import SHIClassifier, load_default_classifier  # noqa: E402
+
+_cache: Dict[str, Optional[SHIClassifier]] = {}
+
+
+def load_classifier() -> Optional[SHIClassifier]:
+    """Charge (une seule fois) le classificateur livré avec le paquet, ou celui de SHI_HOME."""
+    if "clf" not in _cache:
+        _cache["clf"] = load_default_classifier()
+    return _cache["clf"]
+
+
+def classify(text: str):
+    """Catégorie probable d'une description : objet avec label, confidence, probs, uncertain."""
+    clf = load_classifier()
+    if clf is None:
+        raise RuntimeError("Aucun modèle disponible : lancez « python -m shi.cli train-classifier ».")
+    return clf.predict(text)
+
+
+def diagnose(description: str, logs: str = "") -> Dict[str, Any]:
+    """Diagnostic en conseil seulement : catégorie, hypothèses avec preuves, vérifications sûres."""
+    from shi.diagnosis.service import diagnose_text
+
+    return diagnose_text(description, logs, load_classifier())

shi_saash-0.3.0/src/shi/__main__.py

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

shi_saash-0.3.0/src/shi/analysis/code_analyzer.py

@@ -0,0 +1,141 @@
+"""Analyse de code : symboles, zones citées par les tracebacks, signaux statiques.
+
+La syntaxe ne prouve pas la cause d'un incident : ces résultats sont des indices.
+"""
+from __future__ import annotations
+
+import ast
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from shi.config import IGNORE_DIRS
+from shi.security.guard import scan_untrusted
+
+
+@dataclass
+class Symbol:
+    kind: str
+    name: str
+    lineno: int
+
+
+@dataclass
+class Finding:
+    rule: str
+    lineno: int
+    message: str
+
+
+@dataclass
+class Frame:
+    file: str
+    line: int
+    func: str
+
+
+_FRAME = re.compile(r'File "(?P<f>[^"]+)", line (?P<l>\d+)(?:, in (?P<fn>[\w<>]+))?')
+_REQUESTS = {"get", "post", "put", "delete", "patch", "head", "request"}
+
+
+def parse_tracebacks(text: str) -> List[Frame]:
+    return [Frame(m.group("f"), int(m.group("l")), m.group("fn") or "") for m in _FRAME.finditer(text)]
+
+
+def _is_mutable_default(d) -> bool:
+    if isinstance(d, (ast.List, ast.Dict, ast.Set)):
+        return True
+    return (isinstance(d, ast.Call) and isinstance(d.func, ast.Name) and d.func.id in {"list", "dict", "set"}
+            and not d.args and not d.keywords)
+
+
+def analyze_source(source: str) -> Tuple[List[Symbol], List[Finding]]:
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as exc:
+        return [], [Finding("syntax_error", exc.lineno or 0, "erreur de syntaxe : %s" % exc.msg)]
+    symbols: List[Symbol] = []
+    findings: List[Finding] = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            symbols.append(Symbol("fonction", node.name, node.lineno))
+            a = node.args
+            defaults = list(a.defaults) + [d for d in a.kw_defaults if d is not None]
+            if any(_is_mutable_default(d) for d in defaults):
+                findings.append(Finding("mutable_default", node.lineno,
+                                        "argument par défaut mutable dans %s() : l'objet est partagé entre les appels" % node.name))
+        elif isinstance(node, ast.ClassDef):
+            symbols.append(Symbol("classe", node.name, node.lineno))
+        elif isinstance(node, ast.ExceptHandler) and node.type is None:
+            findings.append(Finding("bare_except", node.lineno, "« except: » nu : masque toutes les erreurs"))
+        elif isinstance(node, ast.Compare):
+            if any(isinstance(o, (ast.Eq, ast.NotEq)) for o in node.ops) and any(
+                isinstance(c, ast.Constant) and c.value is None for c in node.comparators
+            ):
+                findings.append(Finding("eq_none", node.lineno, "comparaison « == None » (préférer « is None »)"))
+        elif isinstance(node, ast.Call):
+            f = node.func
+            if (isinstance(f, ast.Attribute) and isinstance(f.value, ast.Name) and f.value.id == "requests"
+                    and f.attr in _REQUESTS and not any(k.arg in ("timeout", None) for k in node.keywords)):
+                findings.append(Finding("requests_no_timeout", node.lineno, "appel requests sans délai d'attente (timeout)"))
+            elif isinstance(f, ast.Name) and f.id in ("eval", "exec"):
+                findings.append(Finding("eval_exec", node.lineno, "usage de %s() : risque d'exécution de code arbitraire" % f.id))
+    return symbols, findings
+
+
+@dataclass
+class RepoScan:
+    files: Dict[str, str] = field(default_factory=dict)  # sources .py analysables (hors tests)
+    findings: Dict[str, List[Finding]] = field(default_factory=dict)
+    symbols: Dict[str, List[Symbol]] = field(default_factory=dict)
+    suspicious: List[dict] = field(default_factory=list)  # instructions suspectes (informatif)
+
+
+_TEXT_SUFFIXES = {".py", ".md", ".txt", ".log", ".cfg", ".ini", ".toml", ".yml", ".yaml", ".json"}
+
+
+def _is_test(rel: str) -> bool:
+    name = os.path.basename(rel)
+    return rel.startswith("tests/") or "/tests/" in rel or name.startswith("test_") or name.endswith("_test.py") or name == "conftest.py"
+
+
+def scan_repo(root, max_files: int = 300, max_bytes: int = 200_000) -> RepoScan:
+    """Lit le dépôt SANS suivre les liens symboliques ; le contenu est non fiable."""
+    root = Path(root).resolve()
+    scan = RepoScan()
+    count = 0
+    for dirpath, dirs, files in os.walk(root, followlinks=False):
+        dirs[:] = sorted(d for d in dirs if d not in IGNORE_DIRS and not os.path.islink(os.path.join(dirpath, d)))
+        for name in sorted(files):
+            full = os.path.join(dirpath, name)
+            if os.path.islink(full) or Path(name).suffix not in _TEXT_SUFFIXES:
+                continue
+            if os.path.getsize(full) > max_bytes:
+                continue
+            count += 1
+            if count > max_files:
+                return scan
+            rel = os.path.relpath(full, root).replace(os.sep, "/")
+            text = Path(full).read_text(encoding="utf-8", errors="replace")
+            scan.suspicious += scan_untrusted(text, rel)
+            if name.endswith(".py") and not _is_test(rel):
+                scan.files[rel] = text
+                syms, finds = analyze_source(text)
+                scan.symbols[rel] = syms
+                if finds:
+                    scan.findings[rel] = finds
+    return scan
+
+
+def match_frames(frames: List[Frame], known_files) -> List[Tuple[str, int, str]]:
+    """Associe les fichiers cités dans un traceback aux fichiers du dépôt (par suffixe)."""
+    out = []
+    for fr in frames:
+        path = fr.file.replace("\\", "/")
+        for rel in known_files:
+            if path == rel or path.endswith("/" + rel):
+                out.append((rel, fr.line, fr.func))
+                break
+    return out