Metadata-Version: 2.4
Name: tipe-architect
Version: 0.2.0
Summary: Générateur automatique de dossiers TIPE complets par IA — MCOT, théorie, simulation, rapport LaTeX, slides Beamer et préparation jury.
Project-URL: Homepage, https://github.com/votre-username/tipe-architect-cli
Project-URL: Repository, https://github.com/votre-username/tipe-architect-cli
Project-URL: Issues, https://github.com/votre-username/tipe-architect-cli/issues
Author: Ismail Himi
License-Expression: MIT
Keywords: ai,cli,concours,cpge,education,latex,tipe
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: Education
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Education
Classifier: Topic :: Scientific/Engineering
Classifier: Topic :: Text Processing :: Markup :: LaTeX
Requires-Python: >=3.11
Requires-Dist: anthropic>=0.100.0
Requires-Dist: google-genai>=0.5.0
Requires-Dist: keyring>=25.7.0
Requires-Dist: nbformat>=5.10.4
Requires-Dist: prompt-toolkit>=3.0.52
Requires-Dist: rich>=15.0.0
Requires-Dist: sympy>=1.14.0
Requires-Dist: typer>=0.25.1
Description-Content-Type: text/markdown

# 🎓 TIPE Architect CLI

> **Générateur automatique de dossiers TIPE complets par Intelligence Artificielle.**
> Un seul `tipe run` et vous obtenez : MCOT, modélisation physique, simulation Python, notebook Jupyter et rapport scientifique — le tout en **LaTeX académique compilable**.

<p align="center">
  <img src="https://img.shields.io/badge/Python-3.11+-blue?logo=python&logoColor=white" alt="Python 3.11+">
  <img src="https://img.shields.io/badge/LaTeX-pdflatex-008080?logo=latex&logoColor=white" alt="LaTeX">
  <img src="https://img.shields.io/badge/IA-Gemini%20%7C%20Claude-blueviolet" alt="Gemini | Claude">
  <img src="https://img.shields.io/badge/CLI-Typer%20%2B%20Rich-green" alt="Typer + Rich">
  <img src="https://img.shields.io/badge/Version-0.2.0-orange" alt="Version">
</p>

---

## 📋 Table des matières

- [Le problème](#-le-problème)
- [La solution](#-la-solution)
- [Installation](#-installation)
- [Guide d'utilisation](#-guide-dutilisation)
  - [1. Configuration](#1-configuration-tipe-config)
  - [2. Initialisation](#2-initialisation-du-projet-tipe-init)
  - [3. Génération](#3-génération-tipe-run)
- [Fichiers générés](#-fichiers-générés)
- [Pipeline détaillé](#-pipeline-détaillé)
- [Exemples de sujets testés](#-exemples-de-sujets-testés)
- [Options avancées](#-options-avancées)
- [Architecture technique](#-architecture-technique)
- [Dépendances](#-dépendances)
- [FAQ](#-faq)
- [Avertissement pédagogique](#-avertissement-pédagogique)

---

## 🎯 Le problème

Les étudiants en classes préparatoires (CPGE — MPSI, MP, PSI, PCSI, MPI, PTSI) consacrent des **semaines entières** à des tâches de production pour leur TIPE :

- Chercher des modèles mathématiques dans la littérature
- Déboguer du code Python de simulation
- Mettre en page des rapports LaTeX
- Rédiger la MCOT au bon format officiel

Ce temps est **volé à l'essentiel** : comprendre la physique en profondeur et **préparer l'oral face au jury**.

## 💡 La solution

**TIPE Architect CLI** génère un dossier TIPE complet de A à Z à partir de **4 inputs** (thème, titre, problématique, objectifs), via l'API Gemini ou Claude.

```
4 inputs  →  5 appels IA en cascade  →  5 fichiers LaTeX + Python + Jupyter
```

> *L'IA fait 100 % du travail de production. L'élève investit ce temps libéré dans une seule chose : comprendre assez profondément pour répondre à n'importe quelle question du jury, à froid, sans document.*

---

## 🚀 Installation

### Prérequis

- **Python 3.11+**
- **[uv](https://docs.astral.sh/uv/)** (gestionnaire de paquets Python moderne)
- **Une clé API** : [Google Gemini](https://aistudio.google.com/apikey) (gratuit) ou [Anthropic Claude](https://console.anthropic.com/)

### Installation avec uv

```bash
# Cloner le dépôt
git clone https://github.com/votre-username/tipe-architect-cli.git
cd tipe-architect-cli

# Installer les dépendances et le CLI
uv sync
```

### Installation globale (optionnel)

```bash
uv tool install .
```

Après cette commande, `tipe` est disponible depuis n'importe quel terminal.

---

## 📖 Guide d'utilisation

### 1. Configuration (`tipe config`)

À exécuter **une seule fois** pour configurer votre fournisseur IA et votre filière.

```
$ tipe config

Configuration de TIPE Architect
Fournisseur IA (tapez 'anthropic' ou 'gemini') [anthropic]: gemini
Clé API Gemini: ************************************
Modèle Gemini [gemini-2.5-flash]: gemini-2.5-flash
Votre filière (mpsi, mp, psi, pcsi, mpi, ptsi) [mpsi]: mp
Configuration sauvegardée avec succès !
```

| Paramètre | Options | Défaut |
|---|---|---|
| **Fournisseur** | `anthropic`, `gemini` | `anthropic` |
| **Modèle Gemini** | `gemini-2.5-flash`, `gemini-2.5-pro`, etc. | `gemini-2.5-flash` |
| **Modèle Anthropic** | `claude-3-5-sonnet-20241022`, etc. | `claude-3-5-sonnet-20241022` |
| **Filière** | `mpsi`, `mp`, `psi`, `pcsi`, `mpi`, `ptsi` | `mpsi` |

> 🔐 **Sécurité** : La clé API est stockée dans le **trousseau de clés natif de votre OS** (Windows Credential Manager, macOS Keychain, Linux Secret Service) via `keyring`. Elle n'est jamais écrite en clair dans un fichier.

---

### 2. Initialisation du projet (`tipe init`)

Saisissez les 4 informations de base de votre TIPE :

```
$ tipe init

Initialisation d'un nouveau projet TIPE
Thème annuel (ex: Jeux et Sports): Jeux et Sports
Titre provisoire du projet: Modélisation aérodynamique d'un ballon de football en rotation

Problématique (Tapez Entrée, puis saisissez votre texte.
Appuyez sur Echap puis Entrée pour valider) :
> Dans quelle mesure l'effet Magnus, induit par la rotation d'un ballon
> de football, permet-il de modéliser quantitativement la déviation de
> sa trajectoire par rapport au tir sans effet, et quelles sont les
> limites de ce modèle en régime turbulent ?

Objectifs initiaux (Tapez Entrée, puis saisissez votre texte.
Appuyez sur Echap puis Entrée pour valider) :
> 1. Établir les équations du mouvement via le nombre de Reynolds
> 2. Implémenter une simulation Runge-Kutta 4
> 3. Analyser la sensibilité aux paramètres clés

Projet initialisé et sauvegardé dans 'tipe_project.json'.
Vous pouvez maintenant lancer tipe run.
```

Cela crée un fichier `tipe_project.json` dans le répertoire courant :

```json
{
    "theme": "Jeux et Sports",
    "title": "Modélisation aérodynamique d'un ballon de football en rotation",
    "problematique": "Dans quelle mesure l'effet Magnus...",
    "objectives": "1. Établir les équations..."
}
```

---

### 3. Génération (`tipe run`)

Lancez le pipeline complet :

```
$ tipe run

Démarrage de la génération pour le projet : Modélisation aérodynamique d'un ballon...
Filière : MP | Fournisseur : gemini (gemini-2.5-flash)
Dossier cible : Modélisation_aérodynamique_dun_ballon_de_football_en_rotation

>> ÉTAPE 1/5 : Génération de la MCOT (LaTeX)
┌─ Génération en cours (gemini-2.5-flash)... ─────────────────────────────┐
│ \documentclass[12pt, a4paper]{article}                                   │
│ ...                                                                      │
└──────────────────────────────────────────────────────────────────────────┘
✅ 00_MCOT.tex généré.

>> ÉTAPE 2/5 : Génération de la Théorie & Modélisation (LaTeX)
...
✅ 01_Theorie.tex généré.

>> ÉTAPE 3/5 : Génération du Code Python & Notebook Jupyter
...
✅ 02_Simulation.py + 02_Simulation.ipynb générés.

>> ÉTAPE 4/5 : Auto-Healing & Vérification
  ↳ Auto-healing — Exécution du script (tentative 1/3)...
  ✅ Script exécuté sans erreur !
  ↳ Vérification dimensionnelle SymPy...
  ✓ Vérification dimensionnelle : 12 paramètre(s) indexé(s), 8 équation(s) LaTeX détectée(s).
  ✓ Tous les paramètres disposent d'une unité SI renseignée.
✅ Étape Auto-Healing terminée.

>> ÉTAPE 5/5 : Génération du Rapport Scientifique (LaTeX)
...
✅ 03_Rapport.tex généré.

┌─────────────────────────────────────────────────────────────┐
│           ✅ Génération terminée avec succès !               │
├────────────────────┬─────────────────────────────┬──────────┤
│ Fichier            │ Contenu                     │   Taille │
├────────────────────┼─────────────────────────────┼──────────┤
│ 00_MCOT.tex        │ Document officiel MCOT      │   3.1 Ko │
│ 01_Theorie.tex     │ Théorie & Modélisation      │  18.5 Ko │
│ 02_Simulation.py   │ Script de simulation        │  12.3 Ko │
│ 02_Simulation.ipynb│ Notebook Jupyter interactif  │  15.1 Ko │
│ 03_Rapport.tex     │ Rapport scientifique        │  22.7 Ko │
└────────────────────┴─────────────────────────────┴──────────┘

📁 Dossier de sortie : Modélisation_aérodynamique_dun_ballon_de_football_en_rotation

┌─ ⚠  AVERTISSEMENT PÉDAGOGIQUE ──────────────────────────────────────────┐
│                                                                          │
│  Ce dossier est un point de départ, pas une fin en soi.                  │
│  Le jury sanctionne sévèrement les élèves qui récitent sans comprendre.  │
│  Chaque équation doit être maîtrisée. Chaque ligne de code doit pouvoir  │
│  être expliquée. Chaque hypothèse doit être défendue oralement.          │
│                                                                          │
│  L'IA a fait le travail de production. La maîtrise vous appartient.      │
│                                                                          │
└──────────────────────────────────────────────────────────────────────────┘
```

> ⏱ **Durée typique** : 3 à 5 minutes selon le modèle et la complexité du sujet.

---

## 📁 Fichiers générés

Après `tipe run`, un dossier est créé avec les fichiers suivants :

| Fichier | Format | Compilation | Contenu |
|---|---|---|---|
| `00_MCOT.tex` | LaTeX | `pdflatex 00_MCOT.tex` | Document officiel MCOT pour les concours (SCEI) |
| `01_Theorie.tex` | LaTeX | `pdflatex 01_Theorie.tex` | Modèle physique : hypothèses justifiées, équations numérotées, paramètres SI |
| `02_Simulation.py` | Python | `python 02_Simulation.py` | Simulation numérique commentée ligne par ligne |
| `02_Simulation.ipynb` | Jupyter | `jupyter lab` | Notebook interactif découpé en cellules par section |
| `03_Rapport.tex` | LaTeX | `pdflatex 03_Rapport.tex` | Rapport scientifique complet avec bibliographie |

### Compiler les fichiers LaTeX

Chaque fichier `.tex` est **autonome** — il contient un preamble complet avec tous les packages nécessaires. Compilation en une seule commande :

```bash
cd Modélisation_aérodynamique_dun_ballon_de_football_en_rotation/

# Compiler un fichier
pdflatex 00_MCOT.tex
pdflatex 01_Theorie.tex
pdflatex 03_Rapport.tex

# Ou compiler tout d'un coup
for f in *.tex; do pdflatex "$f"; done
```

### Packages LaTeX utilisés

Les documents générés s'appuient sur ces packages standards :

| Package | Rôle |
|---|---|
| `amsmath`, `amssymb`, `physics` | Équations mathématiques professionnelles |
| `siunitx` | Unités SI propres : `\SI{9.81}{\metre\per\second\squared}` |
| `booktabs` | Tableaux académiques (`\toprule`, `\midrule`, `\bottomrule`) |
| `tcolorbox` | Encadrés colorés pour les hypothèses |
| `listings` | Code Python avec coloration syntaxique |
| `hyperref` | Liens cliquables et références croisées |
| `babel(french)` | Typographie française |
| `microtype` | Micro-typographie (crénage, protrusion) |

---

## ⚙️ Pipeline détaillé

Le pipeline exécute **5 appels IA en cascade**, chaque appel lisant le contexte du précédent :

```
┌─────────────────────────────────────────────────────────────────────┐
│  ÉTAPE 1 · MCOT                                                     │
│  Input  : 4 informations de l'élève (thème, titre, problématique,   │
│           objectifs)                                                 │
│  Output : 00_MCOT.tex                                               │
│  Contenu: Positionnement, mots-clés FR/EN, objectifs SMART,         │
│           problématique reformulée, résumé 100 mots                 │
└─────────────────────────┬───────────────────────────────────────────┘
                          │ La MCOT alimente la théorie
┌─────────────────────────▼───────────────────────────────────────────┐
│  ÉTAPE 2 · Théorie & Modélisation                                    │
│  Input  : MCOT générée (contenu LaTeX complet)                       │
│  Output : 01_Theorie.tex                                             │
│  Contenu: Système, hypothèses justifiées (tcolorbox), équations      │
│           numérotées (\label/\eqref), analyse adimensionnelle,       │
│           paramètres numériques (tableau booktabs + siunitx)         │
└─────────────────────────┬───────────────────────────────────────────┘
                          │ La théorie alimente le code
┌─────────────────────────▼───────────────────────────────────────────┐
│  ÉTAPE 3 · Code Python + Notebook                                    │
│  Input  : Théorie complète (LaTeX)                                   │
│  Output : 02_Simulation.py + 02_Simulation.ipynb                     │
│  Contenu: Code structuré en sections (# === SECTION ===),            │
│           chaque ligne commentée, solve_ivp, graphes publication-     │
│           ready, analyse de sensibilité                              │
└─────────────────────────┬───────────────────────────────────────────┘
                          │ Le code est exécuté automatiquement
┌─────────────────────────▼───────────────────────────────────────────┐
│  ÉTAPE 4 · Auto-Healing                                              │
│  Mécanisme :                                                         │
│    1. Exécute 02_Simulation.py via subprocess                        │
│    2. Si erreur → capture le traceback                               │
│    3. Envoie le code + traceback à l'IA pour correction              │
│    4. Recommence (max 3 tentatives)                                  │
│    5. Si échec total → génère 02_Debug_Report.md                     │
│                                                                      │
│  + Vérification dimensionnelle SymPy (non-bloquante)                 │
└─────────────────────────┬───────────────────────────────────────────┘
                          │ Théorie + code validé alimentent le rapport
┌─────────────────────────▼───────────────────────────────────────────┐
│  ÉTAPE 5 · Rapport Scientifique                                      │
│  Input  : Théorie (LaTeX) + Code Python validé                       │
│  Output : 03_Rapport.tex                                             │
│  Contenu: Introduction, système, méthodologie numérique,             │
│           résultats, discussion, conclusion, bibliographie           │
│           Code Python inclus via lstlisting                          │
│           5+ références [À VÉRIFIER]                                 │
└─────────────────────────────────────────────────────────────────────┘
```

---

## 🔬 Exemples de sujets testés

| Thème | Sujet | Filière |
|---|---|---|
| Jeux et Sports | Modélisation aérodynamique d'un ballon de football (effet Magnus) | MP |
| Jeux et Sports | Optimisation de la trajectoire d'un nageur en virage | MPSI |
| *à venir* | Analyse thermique d'un moteur Stirling | PSI |
| *à venir* | Propagation d'ondes sismiques en milieu stratifié | PCSI |

---

## 🛠 Options avancées

### Changer de fournisseur IA

Relancez simplement `tipe config` pour basculer entre Gemini et Claude :

```bash
tipe config
# → Choisir 'gemini' ou 'anthropic'
```

### Modifier un projet existant

Éditez directement `tipe_project.json` puis relancez `tipe run` :

```bash
# Éditer les inputs
notepad tipe_project.json   # Windows
nano tipe_project.json       # Linux/Mac

# Relancer la génération
tipe run
```

### Filières supportées

Le flag `--level` (configuré via `tipe config`) adapte la profondeur de chaque document :

| Filière | Effet sur la génération |
|---|---|
| `mpsi` | EDO 1er ordre, développements limités, Python basique |
| `mp` | EDO avancées, transformées de Laplace, algèbre linéaire, Fourier |
| `psi` | Accent mécanique des fluides, électronique |
| `pcsi` | Physique-Chimie, thermodynamique |
| `mpi` | Accent algorithmique et informatique |
| `ptsi` | Sciences de l'ingénieur, modélisation système |

---

## 🏗 Architecture technique

```
tipe_architect/
├── main.py                  # CLI Typer (init, config, run)
├── config.py                # Keyring + config JSON
│
├── pipeline/
│   ├── ai_client.py         # Client dual Gemini/Claude avec streaming Rich
│   └── runner.py            # Orchestrateur du pipeline 5 étapes
│
├── prompts/
│   ├── mcot.py              # System prompt MCOT (LaTeX)
│   ├── theorie.py           # System prompt Théorie (LaTeX)
│   ├── simulation.py        # System prompt Code Python
│   └── rapport.py           # System prompt Rapport (LaTeX)
│
├── ui/
│   └── console.py           # Spinners, résumé, avertissement pédagogique
│
└── utils/
    ├── files.py             # I/O fichiers + création dossier
    ├── notebook.py          # Génération .ipynb via nbformat
    ├── autohealer.py        # Auto-correction subprocess + LLM
    ├── sympy_check.py       # Vérification dimensionnelle (non-bloquante)
    └── latex_writer.py      # Nettoyage LaTeX + extraction .bib
```

---

## 📦 Dépendances

| Package | Rôle |
|---|---|
| `typer` | Framework CLI avec auto-complétion |
| `rich` | UI terminal : spinners, streaming live, tableaux, panels |
| `prompt-toolkit` | Saisie interactive multiligne |
| `anthropic` | SDK officiel Claude |
| `google-genai` | SDK officiel Gemini |
| `keyring` | Stockage sécurisé de la clé API (trousseau OS natif) |
| `nbformat` | Génération de notebooks Jupyter sans lancer Jupyter |
| `sympy` | Vérification dimensionnelle des équations |

---

## ❓ FAQ

### Combien coûte une génération ?

Avec **Gemini 2.5 Flash** (recommandé) : **gratuit** dans la limite du quota gratuit Google AI Studio. Une génération complète consomme environ 20 000–40 000 tokens en entrée et 15 000–25 000 tokens en sortie.

Avec **Claude** : environ **0.05–0.15 $** par génération complète (5 appels × ~5k tokens sortie).

### Les fichiers LaTeX compilent-ils directement ?

**Oui.** Chaque `.tex` est autonome avec un preamble complet. Il suffit d'un `pdflatex fichier.tex`. Aucune dépendance externe (pas de `biber`, pas de fichier `.bib` séparé — la bibliographie est intégrée via `thebibliography`).

Assurez-vous d'avoir une distribution LaTeX installée (TeX Live, MiKTeX) avec les packages standards.

### Le code Python fonctionne-t-il toujours ?

Le pipeline inclut une **boucle d'auto-healing** : le code est exécuté automatiquement et corrigé par l'IA jusqu'à 3 fois en cas d'erreur. Si l'erreur persiste, un `02_Debug_Report.md` est généré avec les pistes de correction.

### Les références bibliographiques sont-elles fiables ?

**Non — elles sont toutes marquées `[À VÉRIFIER]`.** L'IA peut halluciner des références. Vous **devez** vérifier l'existence de chaque référence avant de soumettre votre TIPE. Le CLI affiche un avertissement explicite à ce sujet.

### Puis-je utiliser cet outil pour un vrai concours ?

L'outil génère un **point de départ de haute qualité**. C'est à vous de :
1. **Comprendre** chaque équation, hypothèse et ligne de code
2. **Vérifier** les références bibliographiques
3. **Personnaliser** le contenu avec vos propres analyses
4. **Maîtriser** le sujet suffisamment pour répondre aux questions du jury

---

## ⚠️ Avertissement pédagogique

> **Ce dossier est un point de départ, pas une fin en soi.**
>
> Le jury sanctionne sévèrement les élèves qui récitent sans comprendre.
> Chaque équation doit être maîtrisée. Chaque ligne de code doit pouvoir être expliquée.
> Chaque hypothèse doit être défendue oralement.
>
> **L'IA a fait le travail de production. La maîtrise vous appartient.**

---

## 🗺 Roadmap

| Phase | Statut | Contenu |
|---|---|---|
| **Semaine 1** | ✅ | CLI + Config + MCOT + Théorie |
| **Semaine 2** | ✅ | Code + Auto-Heal + Rapport + LaTeX-only |
| **Semaine 3** | 🔲 | Slides Beamer (`04_Slides.tex`) + Jury interactif (`tipe jury`) + Points faibles |
| **Semaine 4** | 🔲 | Tests sur sujets réels + Polish UX + Publication PyPI |

---

## 📄 Licence

Ce projet est distribué sous licence MIT.

---

## 👨‍💻 Auteur

Développé par **Ismail Himi** — développeur et concepteur de TIPE Architect CLI.

*Développé avec ❤️ pour les étudiants CPGE — Mai 2026*
