vibetodev 1.0.0__tar.gz

vibetodev-1.0.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: vibetodev
+Version: 1.0.0
+Summary: Transforme n'importe quel projet vibecode en parcours d'apprentissage
+Author: ConnectPro
+License: MIT
+Project-URL: Homepage, https://github.com/connectpro/vibetodev
+Project-URL: Source, https://github.com/connectpro/vibetodev
+Keywords: learning,education,code-analysis,obsidian,ast
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: requires-python
+
+# VibeToDev
+
+Transforme n'importe quel projet Python vibecodé en parcours d'apprentissage structuré.
+
+## Installation
+
+```bash
+pip install vibetodev
+```
+
+Ou depuis les sources :
+
+```bash
+git clone https://github.com/connectpro/vibetodev
+cd vibetodev
+pip install .
+```
+
+## Utilisation
+
+```bash
+# Scanner un projet et generer un vault Obsidian
+vibetodev scan /chemin/vers/mon_projet --output /chemin/vers/mon_vault
+
+# Valider un exercice
+vibetodev check mon_exercice.py
+
+# Initialiser vibetodev dans un projet
+vibetodev init /chemin/vers/mon_projet
+```
+
+## Comment ca marche
+
+1. **Scan** — Analyse AST de tous les fichiers Python, extrait 50+ concepts avec leur position exacte
+2. **Categorisation** — 9 modules pedagogiques (variables, fonctions, classes, etc.)
+3. **Generation** — Cree un vault Obsidian avec lecons, exemples de code, et exercices
+4. **Validation** — Execute et verifie les exercices sans donner la solution
+
+## Licence
+
+MIT

vibetodev-1.0.0/README.md

@@ -0,0 +1,41 @@
+# VibeToDev
+
+Transforme n'importe quel projet Python vibecodé en parcours d'apprentissage structuré.
+
+## Installation
+
+```bash
+pip install vibetodev
+```
+
+Ou depuis les sources :
+
+```bash
+git clone https://github.com/connectpro/vibetodev
+cd vibetodev
+pip install .
+```
+
+## Utilisation
+
+```bash
+# Scanner un projet et generer un vault Obsidian
+vibetodev scan /chemin/vers/mon_projet --output /chemin/vers/mon_vault
+
+# Valider un exercice
+vibetodev check mon_exercice.py
+
+# Initialiser vibetodev dans un projet
+vibetodev init /chemin/vers/mon_projet
+```
+
+## Comment ca marche
+
+1. **Scan** — Analyse AST de tous les fichiers Python, extrait 50+ concepts avec leur position exacte
+2. **Categorisation** — 9 modules pedagogiques (variables, fonctions, classes, etc.)
+3. **Generation** — Cree un vault Obsidian avec lecons, exemples de code, et exercices
+4. **Validation** — Execute et verifie les exercices sans donner la solution
+
+## Licence
+
+MIT

vibetodev-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.backends._legacy:_Backend"
+
+[project]
+name = "vibetodev"
+version = "1.0.0"
+description = "Transforme n'importe quel projet vibecode en parcours d'apprentissage"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "ConnectPro"}
+]
+keywords = ["learning", "education", "code-analysis", "obsidian", "ast"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Education",
+    "Topic :: Software Development :: Code Generators",
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/connectpro/vibetodev"
+Source = "https://github.com/connectpro/vibetodev"
+
+[project.scripts]
+vibetodev = "vibetodev.cli:main"

vibetodev-1.0.0/setup.cfg

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

vibetodev-1.0.0/setup.py

@@ -0,0 +1,38 @@
+"""Transforme n'importe quel projet vibecode en parcours d'apprentissage."""
+from setuptools import setup, find_packages
+from pathlib import Path
+
+this_dir = Path(__file__).parent
+long_description = (this_dir / "README.md").read_text(encoding="utf-8") if (this_dir / "README.md").exists() else ""
+
+setup(
+    name="vibetodev",
+    version="1.0.0",
+    description="Transforme n'importe quel projet vibecode en parcours d'apprentissage",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="ConnectPro",
+    license="MIT",
+    keywords="learning education code-analysis obsidian ast",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Education",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Education",
+        "Topic :: Software Development :: Code Generators",
+    ],
+    packages=find_packages(),
+    entry_points={
+        "console_scripts": [
+            "vibetodev=vibetodev.cli:main",
+        ],
+    },
+    python_requires=">=3.8",
+)

vibetodev-1.0.0/vibetodev/__init__.py

@@ -0,0 +1,5 @@
+"""
+vibetodev — Transforme n'importe quel projet vibecode en parcours d'apprentissage.
+"""
+
+__version__ = "1.0.0"

vibetodev-1.0.0/vibetodev/__main__.py

@@ -0,0 +1,6 @@
+"""python -m vibetodev"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

vibetodev-1.0.0/vibetodev/categorizer.py

@@ -0,0 +1,124 @@
+"""
+Categorise les concepts extraits en modules pedagogiques.
+Assigne un niveau (debutant/intermediaire/avance) et un ordre.
+"""
+
+from collections import defaultdict
+
+# Mapping concept -> module
+CONCEPT_MODULE = {
+    # Module 1 : Variables
+    "type_str": 1, "type_int": 1, "type_bool": 1, "type_float": 1,
+    "type_none": 1, "type_bytes": 1, "chaine": 1,
+    "assignation": 1, "assignation_multiple": 1, "assignation_typee": 1,
+    "assignation_augmentee": 1,
+
+    # Module 2 : Fonctions
+    "fonction_def": 2, "fonction_async": 2, "return": 2, "yield": 2,
+    "type_hint_param": 2, "type_hint_return": 2, "docstring": 2,
+    "decorateur": 2, "lambda": 2,
+
+    # Module 3 : Controle
+    "condition_if": 3, "condition_elif": 3, "condition_else": 3,
+    "boucle_for": 3, "boucle_while": 3, "boucle_async_for": 3,
+    "break": 3, "continue": 3, "ternaire": 3,
+
+    # Module 4 : Gestion d'erreurs
+    "try_except": 4, "try_finally": 4, "raise": 4,
+    "context_manager_with": 4, "context_manager_async_with": 4,
+
+    # Module 5 : Collections
+    "type_list": 5, "type_dict": 5, "type_set": 5, "type_tuple": 5,
+    "comprehension_liste": 5, "comprehension_dict": 5, "comprehension_set": 5,
+    "assignation_index": 5, "slice": 5,
+
+    # Module 6 : Operations
+    "appel_fonction": 6, "appel_methode": 6,
+    "operateur_comparaison": 6, "operateur_logique": 6,
+    "fstring": 6, "binop_Add": 6, "binop_Sub": 6, "binop_Mult": 6,
+    "binop_Div": 6, "unpacking": 6, "walrus_operator": 6,
+
+    # Module 7 : Imports
+    "import_module": 7, "import_from": 7,
+
+    # Module 8 : Classes et Objets
+    "class_def": 8,
+    "assignation_attr": 8,
+
+    # Module 9 : Programmation avancee
+    # (tout ce qui n'a pas encore ete categorise)
+}
+
+NOMS_MODULES = {
+    1: "01_Variables_et_Types",
+    2: "02_Fonctions",
+    3: "03_Structures_de_Controle",
+    4: "04_Gestion_d_Erreurs",
+    5: "05_Collections",
+    6: "06_Operations_et_Appels",
+    7: "07_Imports_et_Modules",
+    8: "08_Classes_et_Objets",
+    9: "09_Concepts_Avances",
+}
+
+TITRES_MODULES = {
+    1: "Variables et types de donnees",
+    2: "Les fonctions",
+    3: "Structures de controle",
+    4: "Gestion d'erreurs",
+    5: "Collections (listes, dicts, sets, tuples)",
+    6: "Operations et appels",
+    7: "Imports et modules",
+    8: "Classes et objets",
+    9: "Concepts avances (async, decorateurs, etc.)",
+}
+
+NIVEAU_CONCEPT = {
+    "type_str": "debutant", "type_int": "debutant", "type_bool": "debutant",
+    "type_float": "debutant", "type_none": "debutant", "chaine": "debutant",
+    "assignation": "debutant", "assignation_multiple": "debutant",
+    "assignation_augmentee": "debutant",
+    "fonction_def": "debutant", "return": "debutant",
+    "docstring": "debutant",
+    "condition_if": "debutant", "condition_else": "debutant",
+    "boucle_for": "debutant",
+    "type_list": "debutant", "type_dict": "debutant",
+    "fstring": "debutant",
+    "import_module": "debutant", "import_from": "debutant",
+    "appel_fonction": "debutant",
+    "appel_methode": "debutant",
+    "operateur_comparaison": "debutant",
+    "operateur_logique": "debutant",
+    "type_float": "debutant",
+    "break": "debutant", "continue": "debutant",
+    "condition_elif": "intermediaire",
+    "assignation_index": "intermediaire",
+    "type_set": "intermediaire", "type_tuple": "intermediaire",
+    "assignation_typee": "intermediaire",
+    "type_hint_param": "intermediaire",
+    "try_except": "intermediaire",
+    "context_manager_with": "intermediaire",
+    "comprehension_liste": "intermediaire",
+    "decorateur": "avance",
+    "lambda": "avance",
+    "yield": "avance",
+    "class_def": "avance",
+    "comprehension_dict": "avance",
+    "walrus_operator": "avance",
+    "fonction_async": "avance",
+    "boucle_async_for": "avance",
+    "context_manager_async_with": "avance",
+}
+
+
+def categorize_concepts(concepts_bruts):
+    """
+    Prend {concept: [occurences]} et retourne {module_id: {concept: occurences}}.
+    """
+    modules = defaultdict(lambda: defaultdict(list))
+
+    for concept, occs in concepts_bruts.items():
+        module_id = CONCEPT_MODULE.get(concept, 9)  # defaut: avance
+        modules[module_id][concept] = occs
+
+    return dict(sorted(modules.items()))

vibetodev-1.0.0/vibetodev/cli.py

@@ -0,0 +1,132 @@
+"""
+CLI principale de vibetodev.
+Usage:
+    vibetodev scan <chemin_projet> [--output <chemin_vault>]
+    vibetodev check <fichier_exercice>
+    vibetodev init <chemin_projet>
+    vibetodev serve
+"""
+
+import argparse
+import sys
+import os
+from pathlib import Path
+
+from .scanner import scan_project
+from .categorizer import categorize_concepts
+from .generator import generate_vault
+from .validator import validate_exercise
+
+
+def cmd_scan(args):
+    """Analyse un projet et genere un vault Obsidian."""
+    source = Path(args.source).resolve()
+    if not source.exists():
+        print(f"Erreur: '{source}' n'existe pas.")
+        return 1
+
+    output = Path(args.output).resolve() if args.output else source / ".vibetodev-vault"
+
+    print(f"Scan de {source}...")
+    concepts = scan_project(source, args.recursive)
+
+    if not concepts:
+        print("Aucun concept trouve.")
+        return 1
+
+    total = sum(len(v) for v in concepts.values())
+    print(f"-> {len(concepts)} concepts distincts, {total} occurrences")
+
+    print("Categorisation...")
+    modules = categorize_concepts(concepts)
+
+    print("Generation du vault Obsidian...")
+    generate_vault(modules, concepts, output)
+
+    print(f"\nVault cree dans: {output}")
+    print(f"Ouvre ce dossier dans Obsidian pour voir les lecons.")
+    return 0
+
+
+def cmd_check(args):
+    """Valide un exercice."""
+    fichier = Path(args.fichier).resolve()
+    if not fichier.exists():
+        print(f"Erreur: '{fichier}' introuvable.")
+        return 1
+
+    result = validate_exercise(fichier, args.concept)
+    if result["status"] == "success":
+        print("RESULTAT: VALIDE")
+        for r in result.get("reussites", []):
+            print(f"  [OK] {r}")
+        print(result.get("message", ""))
+        return 0
+    elif result["status"] == "partial":
+        print("RESULTAT: PARTIEL")
+        for r in result.get("reussites", []):
+            print(f"  [OK] {r}")
+        for e in result.get("erreurs", []):
+            print(f"  [A CORRIGER] {e}")
+        print(f"Indice: {result.get('hint', '')}")
+        return 1
+    else:
+        print("RESULTAT: ERREUR")
+        print(result.get("message", ""))
+        print(f"Indice: {result.get('hint', '')}")
+        return 1
+
+
+def cmd_init(args):
+    """Initialise un projet pour vibetodev."""
+    source = Path(args.source).resolve()
+    if not source.exists():
+        print(f"Erreur: '{source}' n'existe pas.")
+        return 1
+
+    vibetodev_dir = source / ".vibetodev"
+    vibetodev_dir.mkdir(exist_ok=True)
+
+    print(f"VibeToDev initialise dans {source}")
+    print(f"Fichier de config: {vibetodev_dir / 'config.json'}")
+    print(f"\nProchaine etape: vibetodev scan {source}")
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="vibetodev",
+        description="Transforme un projet vibecode en parcours d'apprentissage",
+    )
+    parser.add_argument("--version", action="version", version="vibetodev 1.0.0")
+
+    sub = parser.add_subparsers(dest="command", help="Commande")
+
+    # scan
+    p_scan = sub.add_parser("scan", help="Analyser un projet et generer un vault")
+    p_scan.add_argument("source", help="Dossier du projet a analyser")
+    p_scan.add_argument("-o", "--output", help="Dossier de sortie du vault (defaut: <source>/.vibetodev-vault)")
+    p_scan.add_argument("-r", "--recursive", action="store_true", default=True, help="Scan recursif (defaut: True)")
+    p_scan.set_defaults(func=cmd_scan)
+
+    # check
+    p_check = sub.add_parser("check", help="Valider un exercice")
+    p_check.add_argument("fichier", help="Fichier exercice a valider")
+    p_check.add_argument("--concept", help="Concept a valider (optionnel)")
+    p_check.set_defaults(func=cmd_check)
+
+    # init
+    p_init = sub.add_parser("init", help="Initialiser vibetodev dans un projet")
+    p_init.add_argument("source", help="Dossier du projet")
+    p_init.set_defaults(func=cmd_init)
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

vibetodev-1.0.0/vibetodev/generator.py

@@ -0,0 +1,240 @@
+"""
+Genere un vault Obsidian complet avec lecons, exercices et liens vers le code.
+"""
+
+import os
+from pathlib import Path
+from collections import defaultdict
+
+from .categorizer import NOMS_MODULES, TITRES_MODULES, NIVEAU_CONCEPT
+
+EXPLICATIONS = {
+    "type_str": "Une **chaine** (str) est du texte entre guillemets.",
+    "type_int": "Un **entier** (int) est un nombre sans virgule.",
+    "type_bool": "Un **booleen** (bool) vaut True ou False.",
+    "type_float": "Un **float** est un nombre decimal.",
+    "type_none": "**None** represente l'absence de valeur.",
+    "chaine": "Une **chaine vide** \"\" est une chaine sans caractere.",
+    "assignation": "L'**assignation** (=) stocke une valeur dans une variable.",
+    "assignation_multiple": "L'**assignation multiple** (=) assigne plusieurs variables en une ligne.",
+    "assignation_typee": "L'**assignation typee** (=) avec annotation de type.",
+    "assignation_augmentee": "L'assignation **augmentee** (+=, -=, etc.) combine operation et assignation.",
+    "fonction_def": "Une **fonction** est un bloc de code reutilisable defini avec `def`.",
+    "fonction_async": "Une **fonction asynchrone** utilise `async def`.",
+    "return": "**return** renvoie une valeur depuis une fonction.",
+    "yield": "**yield** transforme une fonction en generateur.",
+    "type_hint_param": "Les **type hints** (`param: type`) indiquent le type attendu.",
+    "type_hint_return": "Le **type hint de retour** (`-> type`) indique le type de retour.",
+    "docstring": "Une **docstring** (\"""...\""") decrit ce que fait la fonction.",
+    "decorateur": "Un **decorateur** (@) ajoute un comportement a une fonction.",
+    "lambda": "Une **lambda** est une fonction anonyme courte.",
+    "condition_if": "**if** execute un bloc si la condition est vraie.",
+    "condition_elif": "**elif** teste une autre condition.",
+    "condition_else": "**else** s'execute si tout est faux.",
+    "boucle_for": "**for** parcourt chaque element d'une collection.",
+    "boucle_while": "**while** repete tant que la condition est vraie.",
+    "boucle_async_for": "**async for** parcourt un iterateur asynchrone.",
+    "break": "**break** sort de la boucle immediatement.",
+    "continue": "**continue** passe a l'iteration suivante.",
+    "ternaire": "Le **ternaire** (`x if cond else y`) est un if en une ligne.",
+    "try_except": "**try/except** capture les erreurs sans planter.",
+    "try_finally": "**finally** s'execute toujours, erreur ou pas.",
+    "raise": "**raise** declenche une erreur volontairement.",
+    "context_manager_with": "**with** gere automatiquement les ressources.",
+    "context_manager_async_with": "**async with** pour les contextes asynchrones.",
+    "type_list": "Une **liste** `[]` est une collection ordonnee et modifiable.",
+    "type_dict": "Un **dict** `{}` associe des cles a des valeurs.",
+    "type_set": "Un **set** `{}` est un ensemble sans doublon.",
+    "type_tuple": "Un **tuple** `()` est immuable.",
+    "comprehension_liste": "Une **comprehension** cree une liste en une ligne.",
+    "comprehension_dict": "Une **comprehension** cree un dict en une ligne.",
+    "comprehension_set": "Une **comprehension** cree un set en une ligne.",
+    "assignation_index": "Modifie un element par son index ou sa cle.",
+    "slice": "Le **slicing** `[debut:fin:pas]` extrait une portion.",
+    "appel_fonction": "**appel de fonction** () execute une fonction.",
+    "appel_methode": "Une **methode** . est une fonction attachee a un objet.",
+    "operateur_comparaison": "Compare avec ==, !=, <, >, in, etc.",
+    "operateur_logique": "Combine avec **and**, **or**, **not**.",
+    "fstring": "Les **f-strings** f\"...\" integrent des variables.",
+    "import_module": "**import module** importe tout un module.",
+    "import_from": "**from module import** importe specifiquement.",
+    "class_def": "Une **classe** definit un nouveau type d'objet.",
+    "assignation_attr": "Modifie un attribut d'objet (`objet.attr = ...`).",
+    "unpacking": "L'**unpacking** (`*args`, `**kwargs`) decompose des sequences.",
+    "walrus_operator": "L'**operateur morse** (:=) assigne dans une expression.",
+}
+
+
+def generate_vault(modules, concepts_bruts, output_dir):
+    """Genere le vault Obsidian dans output_dir."""
+    output = Path(output_dir)
+    output.mkdir(parents=True, exist_ok=True)
+    obsidian_dir = output / ".obsidian"
+    obsidian_dir.mkdir(exist_ok=True)
+
+    _generate_index(modules, concepts_bruts, output)
+    _generate_obsidian_config(obsidian_dir)
+
+    for module_id, concepts in modules.items():
+        _generate_module(module_id, concepts, output)
+
+    print(f"Vault genere dans {output}/")
+    print(f"  -> {len(modules)} modules")
+    print(f"  -> {sum(len(c) for c in concepts_bruts.values())} concepts au total")
+
+
+def _generate_obsidian_config(obsidian_dir):
+    """Cree la config minimale Obsidian."""
+    core = {
+        "file-explorer": True, "global-search": True, "switcher": True,
+        "graph": True, "backlink": True, "outgoing-link": True,
+        "tag-pane": True, "page-preview": True, "templates": True,
+        "command-palette": True, "outline": True, "word-count": True,
+        "daily-notes": False,
+    }
+    with open(obsidian_dir / "core-plugins.json", "w", encoding="utf-8") as f:
+        import json
+        json.dump(core, f, indent=2)
+
+    app = {}
+    with open(obsidian_dir / "app.json", "w", encoding="utf-8") as f:
+        json.dump(app, f, indent=2)
+
+
+def _generate_index(modules, concepts_bruts, output):
+    """Genere la page d'accueil du vault."""
+    path = output / "Index.md"
+    total_concepts = len(concepts_bruts)
+    total_occ = sum(len(v) for v in concepts_bruts.values())
+
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("# VibeToDev — Parcours d'apprentissage\n\n")
+        f.write("Vault genere automatiquement par analyse AST.\n\n")
+        f.write(f"- **{total_concepts} concepts** distincts\n")
+        f.write(f"- **{total_occ} occurrences** dans le code\n\n")
+
+        f.write("## Modules\n\n")
+        f.write("| Module | Contenu |\n")
+        f.write("|--------|--------|\n")
+        for mid in sorted(modules.keys()):
+            nom = NOMS_MODULES.get(mid, f"{mid:02d}")
+            titre = TITRES_MODULES.get(mid, f"Module {mid}")
+            concepts_count = sum(len(v) for v in modules[mid].values())
+            f.write(f"| [[{nom}/Lecon|Module {mid}]] | {titre} ({concepts_count} occ) |\n")
+
+        f.write("\n## Tous les concepts\n\n")
+        f.write("| Concept | Niveau | Occurrences |\n")
+        f.write("|---------|--------|------------|\n")
+        for concept in sorted(concepts_bruts.keys()):
+            niveau = NIVEAU_CONCEPT.get(concept, "intermediaire")
+            occ = len(concepts_bruts[concept])
+            f.write(f"| {concept} | {niveau} | {occ} |\n")
+
+
+def _generate_module(module_id, concepts, output):
+    """Genere la lecon pour un module."""
+    nom_dossier = NOMS_MODULES.get(module_id, f"{module_id:02d}")
+    titre = TITRES_MODULES.get(module_id, f"Module {module_id}")
+    dossier = output / nom_dossier
+    dossier.mkdir(exist_ok=True)
+
+    path = dossier / "Lecon.md"
+    total_occ_module = sum(len(v) for v in concepts.values())
+
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(f"# Module {module_id} : {titre}\n\n")
+        f.write(f"> {total_occ_module} occurrences dans le projet\n\n")
+
+        for concept in sorted(concepts.keys()):
+            occs = concepts[concept]
+            nom_concept = concept.replace("_", " ").title()
+            explication = EXPLICATIONS.get(concept, "")
+            niveau = NIVEAU_CONCEPT.get(concept, "intermediaire")
+
+            f.write(f"## {nom_concept}\n")
+            f.write(f"_{len(occs)} occurrences | Niveau: {niveau}_\n\n")
+
+            if explication:
+                f.write(f"{explication}\n\n")
+
+            # Exemples de code
+            f.write("### Dans le code\n\n")
+            for i, occ in enumerate(occs[:3]):
+                f.write(f"**Exemple {i+1}** — `{occ['fichier']}:{occ['ligne']}`\n\n")
+                f.write("```python\n")
+                f.write(f"{occ['code']}\n")
+                f.write("```\n\n")
+
+            # Autres occurrences
+            if len(occs) > 3:
+                par_fichier = defaultdict(list)
+                for occ in occs[3:]:
+                    par_fichier[occ["fichier"]].append(occ["ligne"])
+                f.write(f"**{len(occs) - 3} autres occurrences :**\n\n")
+                for fichier, lignes in sorted(par_fichier.items()):
+                    lignes_str = ", ".join(str(l) for l in lignes[:5])
+                    if len(lignes) > 5:
+                        lignes_str += f", ... ({len(lignes) - 5} de plus)"
+                    f.write(f"- `{fichier}` : lignes {lignes_str}\n")
+                f.write("\n")
+
+            # Mini-exercice genere
+            f.write("### Mini-exercice\n\n")
+            f.write("```python\n")
+            f.write(_generer_exercice(concept))
+            f.write("\n```\n\n")
+
+            f.write("---\n\n")
+
+        # Navigation
+        f.write("## Navigation\n\n")
+        if module_id > 1:
+            prev = NOMS_MODULES.get(module_id - 1)
+            f.write(f"- [[../{prev}/Lecon|Module {module_id - 1}]]\n")
+        if module_id < 9:
+            next_mod = NOMS_MODULES.get(module_id + 1)
+            f.write(f"- [[../{next_mod}/Lecon|Module {module_id + 1}]]\n")
+        f.write("- [[Index|Retour a l'accueil]]\n")
+
+
+def _generer_exercice(concept):
+    """Genere un mini-exercice adapte au concept."""
+    exercices = {
+        "type_str": 'nom = "VotrePrenom"\nprint(type(nom))\nprint(nom.upper())',
+        "type_int": 'age = 25\nannee = 2026 - age\nprint(annee)',
+        "type_bool": 'est_actif = True\nif est_actif:\n    print("Actif")',
+        "type_float": 'prix = 19.99\ntva = prix * 0.2\nprint(tva)',
+        "type_none": 'resultat = None\nif resultat is None:\n    print("Pas de resultat")',
+        "assignation": 'nom = "Sophie"\nage = 28\nprint(nom, age)',
+        "fonction_def": 'def saluer(nom):\n    return f"Bonjour {nom}"\nprint(saluer("Sophie"))',
+        "return": 'def addition(a, b):\n    return a + b\nprint(addition(3, 4))',
+        "condition_if": 'note = 15\nif note >= 10:\n    print("Reussi")',
+        "boucle_for": 'noms = ["Alice", "Bob", "Charlie"]\nfor n in noms:\n    print(n)',
+        "try_except": 'try:\n    x = 1 / 0\nexcept ZeroDivisionError:\n    print("Division par zero")',
+        "type_list": 'fruits = ["pomme", "banane"]\nfruits.append("kiwi")\nprint(fruits[0])',
+        "type_dict": 'profil = {"nom": "Alice", "age": 30}\nprint(profil["nom"])',
+        "type_set": 'a = {"x", "y"}\nb = {"y", "z"}\nprint(a & b)  # intersection',
+        "type_tuple": 'coords = (48.85, 2.35)\nprint(coords[0])',
+        "comprehension_liste": 'nombres = [1, 2, 3, 4, 5]\npairs = [n for n in nombres if n % 2 == 0]\nprint(pairs)',
+        "appel_fonction": 'print("Hello")\nlen([1, 2, 3])',
+        "appel_methode": 'texte = "Bonjour"\nprint(texte.lower())\nprint(texte.upper())',
+        "fstring": 'nom = "Sophie"\nprint(f"Bonjour {nom}")',
+        "import_module": 'import math\nprint(math.sqrt(16))',
+        "import_from": 'from math import sqrt\nprint(sqrt(16))',
+        "decorateur": 'def mon_decorateur(f):\n    def wrapper():\n        print("Avant")\n        f()\n        print("Apres")\n    return wrapper\n\n@mon_decorateur\ndef dire_bonjour():\n    print("Bonjour")',
+        "lambda": 'carre = lambda x: x ** 2\nprint(carre(5))',
+        "class_def": 'class Chien:\n    def __init__(self, nom):\n        self.nom = nom\n    def aboyer(self):\n        return "Woof"\n\nmedor = Chien("Medor")\nprint(medor.aboyer())',
+        "context_manager_with": 'with open("test.txt", "w") as f:\n    f.write("Hello")',
+        "break": 'for i in range(10):\n    if i == 5:\n        break\n    print(i)',
+        "continue": 'for i in range(5):\n    if i == 2:\n        continue\n    print(i)',
+        "operateur_comparaison": 'a, b = 5, 10\nprint(a < b)\nprint(a == b)',
+        "operateur_logique": 'age, pays = 20, "FR"\nif age >= 18 and pays == "FR":\n    print("OK")',
+        "slice": 'liste = [0, 1, 2, 3, 4, 5]\nprint(liste[1:4])\nprint(liste[::-1])',
+        "assignation_index": 'liste = [1, 2, 3]\nliste[0] = 99\nprint(liste)',
+        "assignation_multiple": 'a, b, c = 1, 2, 3\nprint(a, b, c)',
+        "assignation_augmentee": 'compteur = 0\ncompteur += 1\nprint(compteur)',
+        "ternaire": 'age = 20\nstatut = "majeur" if age >= 18 else "mineur"\nprint(statut)',
+        "yield": 'def compter(n):\n    for i in range(n):\n        yield i\nfor x in compter(3):\n    print(x)',
+        "walrus_operator": 'if (n := len([1, 2, 3])) > 0:\n    print(f"Longueur: {n}")',
+    }
+    return exercices.get(concept, f'# Exercice: {concept}\n# Ecris du code qui utilise "{concept}"\npass')

vibetodev-1.0.0/vibetodev/scanner.py

@@ -0,0 +1,277 @@
+"""
+Scanner AST : analyse tous les fichiers Python d'un projet
+et extrait chaque concept avec sa position exacte (fichier:ligne).
+"""
+
+import ast
+import os
+from pathlib import Path
+from collections import defaultdict
+
+IGNORE_DIRS = {"__pycache__", "venv", ".venv", "node_modules", ".git", ".vibetodev", ".vibetodev-vault"}
+IGNORE_FILES = {"__init__.py"}
+
+
+class ConceptExtractor(ast.NodeVisitor):
+    """Visite l'AST et extrait les concepts avec fichier:ligne."""
+
+    def __init__(self, fichier_rel, lignes_source):
+        self.fichier = fichier_rel
+        self.lignes = lignes_source
+        self.concepts = defaultdict(list)
+
+    def _extraire_code(self, node):
+        debut = max(0, getattr(node, 'lineno', 1) - 1)
+        fin = getattr(node, 'end_lineno', debut + 1) or (debut + 1)
+        if fin > len(self.lignes):
+            fin = len(self.lignes)
+        return "".join(self.lignes[debut:fin]).strip()
+
+    def _add(self, concept, node):
+        self.concepts[concept].append({
+            "fichier": self.fichier,
+            "ligne": getattr(node, 'lineno', 0),
+            "code": self._extraire_code(node),
+        })
+
+    def visit_Import(self, node):
+        for alias in node.names:
+            self._add("import_module", node)
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node):
+        self._add("import_from", node)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        self._add("fonction_def", node)
+        if node.decorator_list:
+            self._add("decorateur", node)
+        for a in node.args.args:
+            if a.annotation:
+                self._add("type_hint_param", a)
+        if node.returns:
+            self._add("type_hint_return", node)
+        body = node.body
+        if body and isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant) and isinstance(body[0].value.value, str):
+            self._add("docstring", node)
+        self.generic_visit(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self._add("fonction_async", node)
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node):
+        self._add("class_def", node)
+        self.generic_visit(node)
+
+    def visit_Lambda(self, node):
+        self._add("lambda", node)
+        self.generic_visit(node)
+
+    def visit_Return(self, node):
+        self._add("return", node)
+        self.generic_visit(node)
+
+    def visit_Yield(self, node):
+        self._add("yield", node)
+        self.generic_visit(node)
+
+    def visit_Assign(self, node):
+        for target in node.targets:
+            if isinstance(target, (ast.Tuple, ast.List)):
+                self._add("assignation_multiple", node)
+            elif isinstance(target, ast.Name):
+                self._add("assignation", node)
+            elif isinstance(target, ast.Subscript):
+                self._add("assignation_index", node)
+            elif isinstance(target, ast.Attribute):
+                self._add("assignation_attr", node)
+        self.generic_visit(node)
+
+    def visit_AnnAssign(self, node):
+        self._add("assignation_typee", node)
+        self.generic_visit(node)
+
+    def visit_AugAssign(self, node):
+        self._add("assignation_augmentee", node)
+        self.generic_visit(node)
+
+    def visit_For(self, node):
+        self._add("boucle_for", node)
+        self.generic_visit(node)
+
+    def visit_AsyncFor(self, node):
+        self._add("boucle_async_for", node)
+        self.generic_visit(node)
+
+    def visit_While(self, node):
+        self._add("boucle_while", node)
+        self.generic_visit(node)
+
+    def visit_Break(self, node):
+        self._add("break", node)
+        self.generic_visit(node)
+
+    def visit_Continue(self, node):
+        self._add("continue", node)
+        self.generic_visit(node)
+
+    def visit_If(self, node):
+        self._add("condition_if", node)
+        if node.orelse:
+            if isinstance(node.orelse[0], ast.If):
+                self._add("condition_elif", node.orelse[0])
+            else:
+                self._add("condition_else", node)
+        self.generic_visit(node)
+
+    def visit_Try(self, node):
+        self._add("try_except", node)
+        if node.finalbody:
+            self._add("try_finally", node)
+        self.generic_visit(node)
+
+    def visit_Raise(self, node):
+        self._add("raise", node)
+        self.generic_visit(node)
+
+    def visit_With(self, node):
+        self._add("context_manager_with", node)
+        self.generic_visit(node)
+
+    def visit_AsyncWith(self, node):
+        self._add("context_manager_async_with", node)
+        self.generic_visit(node)
+
+    def visit_ListComp(self, node):
+        self._add("comprehension_liste", node)
+        self.generic_visit(node)
+
+    def visit_DictComp(self, node):
+        self._add("comprehension_dict", node)
+        self.generic_visit(node)
+
+    def visit_SetComp(self, node):
+        self._add("comprehension_set", node)
+        self.generic_visit(node)
+
+    def visit_List(self, node):
+        if not isinstance(node.ctx, ast.Store):
+            self._add("type_list", node)
+        self.generic_visit(node)
+
+    def visit_Dict(self, node):
+        self._add("type_dict", node)
+        self.generic_visit(node)
+
+    def visit_Set(self, node):
+        self._add("type_set", node)
+        self.generic_visit(node)
+
+    def visit_Tuple(self, node):
+        self._add("type_tuple", node)
+        self.generic_visit(node)
+
+    def visit_Constant(self, node):
+        val = node.value
+        if isinstance(val, str):
+            self._add("chaine" if val == "" else "type_str", node)
+        elif isinstance(val, bool):
+            self._add("type_bool", node)
+        elif isinstance(val, int):
+            self._add("type_int", node)
+        elif isinstance(val, float):
+            self._add("type_float", node)
+        elif val is None:
+            self._add("type_none", node)
+        elif isinstance(val, bytes):
+            self._add("type_bytes", node)
+        self.generic_visit(node)
+
+    def visit_Compare(self, node):
+        self._add("operateur_comparaison", node)
+        self.generic_visit(node)
+
+    def visit_BoolOp(self, node):
+        self._add("operateur_logique", node)
+        self.generic_visit(node)
+
+    def visit_BinOp(self, node):
+        op_type = type(node.op).__name__
+        self._add(f"binop_{op_type}", node)
+        self.generic_visit(node)
+
+    def visit_Call(self, node):
+        if isinstance(node.func, ast.Attribute):
+            self._add("appel_methode", node)
+        elif isinstance(node.func, ast.Name):
+            self._add("appel_fonction", node)
+        self.generic_visit(node)
+
+    def visit_JoinedStr(self, node):
+        self._add("fstring", node)
+        self.generic_visit(node)
+
+    def visit_Slice(self, node):
+        self._add("slice", node)
+        self.generic_visit(node)
+
+    def visit_IfExp(self, node):
+        self._add("ternaire", node)
+        self.generic_visit(node)
+
+    def visit_Starred(self, node):
+        self._add("unpacking", node)
+        self.generic_visit(node)
+
+    def visit_walrus(self, node):
+        """:= operateur morse (Python 3.8+)"""
+        self._add("walrus_operator", node)
+        self.generic_visit(node)
+
+
+def scan_project(source_dir, recursive=True):
+    """
+    Scanne un projet et retourne {concept: [occurences]}.
+    Chaque occurrence a: fichier, ligne, code.
+    """
+    source = Path(source_dir)
+    tous = defaultdict(list)
+    fichiers_trouves = []
+
+    if recursive:
+        for root, dirs, files in os.walk(source):
+            dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+            for f in files:
+                if f.endswith(".py") and f not in IGNORE_FILES:
+                    fichiers_trouves.append(Path(root) / f)
+    else:
+        for f in source.glob("*.py"):
+            if f.name not in IGNORE_FILES:
+                fichiers_trouves.append(f)
+
+    for chemin in sorted(set(fichiers_trouves)):
+        try:
+            rel = str(chemin.relative_to(source.parent)) if source.parent in chemin.parents else str(chemin)
+        except ValueError:
+            rel = str(chemin)
+
+        try:
+            with open(chemin, "r", encoding="utf-8", errors="replace") as f:
+                lignes = f.readlines()
+        except Exception:
+            continue
+
+        try:
+            arbre = ast.parse("".join(lignes))
+        except SyntaxError:
+            continue
+
+        extracteur = ConceptExtractor(rel, lignes)
+        extracteur.visit(arbre)
+
+        for concept, occs in extracteur.concepts.items():
+            tous[concept].extend(occs)
+
+    return dict(tous)

vibetodev-1.0.0/vibetodev/validator.py

@@ -0,0 +1,122 @@
+"""
+Validateur d'exercices : execute le fichier, verifie la sortie,
+et donne un feedback sans reveler la solution.
+"""
+
+import ast
+import sys
+import io
+import traceback
+from pathlib import Path
+
+
+def validate_exercise(fichier, concept=None):
+    """
+    Valide un fichier exercice.
+    Retourne un dict avec status, message, hint.
+    """
+    path = Path(fichier)
+    if not path.exists():
+        return {
+            "status": "error",
+            "message": f"Fichier '{fichier}' introuvable.",
+            "hint": "Cree le fichier avec les variables demandees."
+        }
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            code = f.read()
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Impossible de lire le fichier: {e}",
+            "hint": "Verifie que le fichier est accessible."
+        }
+
+    # Verifie la syntaxe
+    try:
+        tree = ast.parse(code)
+    except SyntaxError as e:
+        return {
+            "status": "error",
+            "message": f"Erreur de syntaxe ligne {e.lineno}: {e.msg}",
+            "hint": f"Verifie les parentheses, les guillemets, et l'indentation vers la ligne {e.lineno}."
+        }
+
+    # Execute le code
+    namespace = {}
+    old_stdout = sys.stdout
+    sys.stdout = io.StringIO()
+    try:
+        exec(code, namespace)
+        output = sys.stdout.getvalue()
+    except Exception as e:
+        sys.stdout = old_stdout
+        tb = traceback.format_exc()
+        return {
+            "status": "error",
+            "message": f"Erreur d'execution: {type(e).__name__}: {e}",
+            "debug": tb.split("\n")[-4:-1],
+            "hint": "Lis la derniere ligne de l'erreur. Que dit-elle ?"
+        }
+    finally:
+        sys.stdout = old_stdout
+
+    # Verifications generiques
+    erreurs = []
+    reussites = []
+
+    # Verifie qu'il y a des variables definies
+    user_vars = {k: v for k, v in namespace.items()
+                 if not k.startswith("_") and not callable(v)}
+    if user_vars:
+        reussites.append(f"{len(user_vars)} variable(s) definie(s)")
+    else:
+        erreurs.append("Aucune variable definie")
+
+    # Verifie qu'il y a un print ou une sortie
+    if output.strip():
+        reussites.append(f"Sortie produite ({len(output)} caracteres)")
+    else:
+        erreurs.append("Aucune sortie (as-tu utilise print() ?)")
+
+    # Verifie les types de base si presents
+    for nom, val in user_vars.items():
+        if isinstance(val, str):
+            reussites.append(f"  {nom}: str OK")
+        elif isinstance(val, int):
+            reussites.append(f"  {nom}: int OK")
+        elif isinstance(val, float):
+            reussites.append(f"  {nom}: float OK")
+        elif isinstance(val, bool):
+            reussites.append(f"  {nom}: bool OK")
+        elif isinstance(val, list):
+            reussites.append(f"  {nom}: list[{len(val)} elements] OK")
+        elif isinstance(val, dict):
+            reussites.append(f"  {nom}: dict[{len(val)} cles] OK")
+        elif isinstance(val, set):
+            reussites.append(f"  {nom}: set[{len(val)} elements] OK")
+        elif isinstance(val, tuple):
+            reussites.append(f"  {nom}: tuple[{len(val)} elements] OK")
+
+    if erreurs and not reussites:
+        return {
+            "status": "error",
+            "message": "\n".join(erreurs),
+            "hint": "Ajoute des variables et un print() pour voir le resultat."
+        }
+
+    if erreurs:
+        return {
+            "status": "partial",
+            "reussites": reussites,
+            "erreurs": erreurs,
+            "hint": "Relis la lecon et verifie ce qui manque."
+        }
+
+    return {
+        "status": "success",
+        "reussites": reussites,
+        "message": "Tout est correct ! Passe au concept suivant.",
+        "output": output.strip()
+    }

vibetodev-1.0.0/vibetodev.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: vibetodev
+Version: 1.0.0
+Summary: Transforme n'importe quel projet vibecode en parcours d'apprentissage
+Author: ConnectPro
+License: MIT
+Project-URL: Homepage, https://github.com/connectpro/vibetodev
+Project-URL: Source, https://github.com/connectpro/vibetodev
+Keywords: learning,education,code-analysis,obsidian,ast
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: requires-python
+
+# VibeToDev
+
+Transforme n'importe quel projet Python vibecodé en parcours d'apprentissage structuré.
+
+## Installation
+
+```bash
+pip install vibetodev
+```
+
+Ou depuis les sources :
+
+```bash
+git clone https://github.com/connectpro/vibetodev
+cd vibetodev
+pip install .
+```
+
+## Utilisation
+
+```bash
+# Scanner un projet et generer un vault Obsidian
+vibetodev scan /chemin/vers/mon_projet --output /chemin/vers/mon_vault
+
+# Valider un exercice
+vibetodev check mon_exercice.py
+
+# Initialiser vibetodev dans un projet
+vibetodev init /chemin/vers/mon_projet
+```
+
+## Comment ca marche
+
+1. **Scan** — Analyse AST de tous les fichiers Python, extrait 50+ concepts avec leur position exacte
+2. **Categorisation** — 9 modules pedagogiques (variables, fonctions, classes, etc.)
+3. **Generation** — Cree un vault Obsidian avec lecons, exemples de code, et exercices
+4. **Validation** — Execute et verifie les exercices sans donner la solution
+
+## Licence
+
+MIT

vibetodev-1.0.0/vibetodev.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.py
+vibetodev/__init__.py
+vibetodev/__main__.py
+vibetodev/categorizer.py
+vibetodev/cli.py
+vibetodev/generator.py
+vibetodev/scanner.py
+vibetodev/validator.py
+vibetodev.egg-info/PKG-INFO
+vibetodev.egg-info/SOURCES.txt
+vibetodev.egg-info/dependency_links.txt
+vibetodev.egg-info/entry_points.txt
+vibetodev.egg-info/top_level.txt

vibetodev-1.0.0/vibetodev.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vibetodev-1.0.0/vibetodev.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vibetodev = vibetodev.cli:main

vibetodev-1.0.0/vibetodev.egg-info/top_level.txt

@@ -0,0 +1 @@
+vibetodev