nogit 0.1.0__py3-none-any.whl

nogit/_watcher_entry.py

@@ -0,0 +1,9 @@
+"""Point d'entrée du watcher lancé en process détaché."""
+
+import sys
+from pathlib import Path
+
+if __name__ == "__main__":
+    project_path = Path(sys.argv[1])
+    from nogit.watcher import run
+    run(project_path)

nogit/automatic.py

@@ -0,0 +1,127 @@
+"""nogit automatic / manual — gère le watcher de snapshots automatiques."""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+from nogit.utils import (
+    register_project,
+    get_project_mode,
+    set_watcher_pid,
+    clear_watcher_pid,
+)
+from nogit.ignore import ensure_nogitignore, load_patterns, is_ignored
+
+
+def _show_tree(project_path: Path, max_depth: int = 3) -> int:
+    """Affiche l'arborescence surveillée. Retourne la profondeur max trouvée."""
+    ensure_nogitignore(project_path)
+    dir_patterns, file_patterns = load_patterns(project_path)
+    max_found = [0]
+
+    def _walk(path: Path, depth: int, prefix: str):
+        if depth > max_depth:
+            max_found[0] = max(max_found[0], depth)
+            return
+        try:
+            entries = sorted(path.iterdir(), key=lambda p: (p.is_file(), p.name))
+        except PermissionError:
+            return
+        entries = [
+            e for e in entries
+            if not is_ignored(e, project_path, dir_patterns, file_patterns)
+        ]
+        for i, entry in enumerate(entries):
+            max_found[0] = max(max_found[0], depth)
+            connector = "└── " if i == len(entries) - 1 else "├── "
+            print(f"  {prefix}{connector}{entry.name}")
+            if entry.is_dir():
+                extension = "    " if i == len(entries) - 1 else "│   "
+                _walk(entry, depth + 1, prefix + extension)
+
+    print(f"\n  {project_path}")
+    _walk(project_path, 1, "")
+    return max_found[0]
+
+
+def run_automatic(project_path: Path):
+    mode, pid = get_project_mode(project_path)
+    if mode == "auto":
+        print(f"[nogit] Watcher déjà actif (PID {pid}).")
+        return
+
+    if project_path == project_path.parent:
+        answer = input(f"  Attention : vous lancez nogit depuis la racine de votre disque ({project_path}). Continuer ? [o/N] : ").strip().lower()
+        if answer not in ("o", "oui", "y", "yes"):
+            print("[nogit] Annulé.")
+            return
+        answer2 = input(f"  Vraiment ? Cela va surveiller tout votre disque. Confirmer ? [o/N] : ").strip().lower()
+        if answer2 not in ("o", "oui", "y", "yes"):
+            print("[nogit] Annulé.")
+            return
+
+    print(f"\n[nogit] Arborescence qui sera surveillée :\n")
+    depth = _show_tree(project_path)
+    print()
+    if depth > 3:
+        answer = input(f"  Attention : ce dossier a une profondeur de {depth}. Êtes-vous sûr d'être dans le bon dossier ? [o/N] : ").strip().lower()
+    else:
+        answer = input("  Activer le watcher automatique ? [o/N] : ").strip().lower()
+    if answer not in ("o", "oui", "y", "yes"):
+        print("[nogit] Annulé.")
+        return
+
+    register_project(project_path)
+
+    # Snapshot initial full
+    from nogit.snapshot import run_full
+    run_full(project_path)
+
+    # Lancer le watcher dans un terminal visible
+    cmd = [sys.executable, "-m", "nogit._watcher_entry", str(project_path)]
+    if sys.platform == "win32":
+        proc = subprocess.Popen(
+            ["cmd", "/c", "start", "nogit watcher", sys.executable, "-m", "nogit._watcher_entry", str(project_path)],
+            creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
+        )
+    else:
+        terminals = ["gnome-terminal", "xterm", "konsole"]
+        launched = False
+        for term in terminals:
+            try:
+                proc = subprocess.Popen(
+                    [term, "--", sys.executable, "-m", "nogit._watcher_entry", str(project_path)],
+                    start_new_session=True,
+                )
+                launched = True
+                break
+            except FileNotFoundError:
+                continue
+        if not launched:
+            proc = subprocess.Popen(
+                cmd,
+                start_new_session=True,
+                close_fds=True,
+            )
+
+    print(f"[nogit] Watcher démarré dans un nouveau terminal.")
+
+
+def run_manual(project_path: Path):
+    mode, pid = get_project_mode(project_path)
+    if mode == "manual":
+        print("[nogit] Ce projet est déjà en mode manuel.")
+        return
+
+    # Tuer le watcher
+    try:
+        if sys.platform == "win32":
+            subprocess.run(["taskkill", "/PID", str(pid), "/F"], capture_output=True)
+        else:
+            os.kill(pid, 15)  # SIGTERM
+    except OSError:
+        pass
+
+    clear_watcher_pid(project_path)
+    print(f"[nogit] Watcher arrêté. Projet repassé en mode manuel.")

nogit/backups.py

@@ -0,0 +1,184 @@
+"""nogit backups — liste les snapshots d'un projet ou de tous les projets."""
+
+from pathlib import Path
+from datetime import datetime
+from nogit.utils import load_registry, save_registry, get_project_mode, get_external_backup_dir, set_external_backup_dir
+
+
+def _format_date(stem: str) -> str:
+    try:
+        dt = datetime.strptime(stem, "%Y-%m-%dT%H-%M-%S")
+        return dt.strftime("%d/%m/%Y %H:%M:%S")
+    except ValueError:
+        return stem
+
+
+def _format_size(size_bytes: int) -> str:
+    if size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    return f"{size_bytes / (1024 * 1024):.1f} MB"
+
+
+def _list_snapshots(project_path: Path) -> list[Path]:
+    """Retourne les snapshots d'un projet triés du plus récent au plus ancien."""
+    snap_dir = project_path / ".nogit" / "snapshots"
+    if not snap_dir.exists():
+        return []
+    return sorted(snap_dir.glob("*.zip"), reverse=True)
+
+
+def _show_snapshots_and_diff(project_path: Path):
+    from nogit import diff as diff_module
+    from nogit import restore as restore_module
+
+    snapshots = _list_snapshots(project_path)
+    if not snapshots:
+        print("  Aucun snapshot trouvé.")
+        return
+
+    print(f"\n  Snapshots de {project_path}")
+    print()
+    for i, snap in enumerate(snapshots, 1):
+        size = _format_size(snap.stat().st_size)
+        date_str = _format_date(snap.stem)
+        print(f"  {i:>3}. {date_str}  ({size})")
+
+    print()
+    action = input("  > [d]iff / [r]estore / Entrée pour annuler : ").strip().lower()
+    if not action:
+        return
+
+    if action in ("d", "diff"):
+        choice = input("  > diff entre (ex: 1 2) : ").strip()
+        parts = choice.split()
+        if len(parts) != 2:
+            print("  Format invalide. Exemple : 1 2")
+            return
+        try:
+            a, b = int(parts[0]) - 1, int(parts[1]) - 1
+            if not (0 <= a < len(snapshots) and 0 <= b < len(snapshots)):
+                print("  Numéros invalides.")
+                return
+            # snap A = le plus ancien (index le plus grand car liste inversée)
+            older, newer = sorted([a, b], reverse=True)
+            diff_module.run(str(snapshots[older]), str(snapshots[newer]))
+        except ValueError:
+            print("  Numéros invalides.")
+
+    elif action in ("r", "restore"):
+        choice = input("  > numéro du snapshot à restaurer : ").strip()
+        try:
+            idx = int(choice)
+            restore_module.run(idx)
+        except ValueError:
+            print("  Numéro invalide.")
+
+
+def run(global_: bool = False, external: bool = False):
+    if external:
+        _run_external()
+    elif global_:
+        _run_global()
+    else:
+        _run_local()
+
+
+def _run_external():
+    ext_dir = get_external_backup_dir()
+    if ext_dir:
+        print(f"\n[nogit] Backup externe configuré : {ext_dir}")
+        if ext_dir.exists():
+            print(f"        Dossier accessible.")
+        else:
+            print(f"        Avertissement : dossier introuvable (disque déconnecté ?)")
+        print()
+        answer = input("  Changer le chemin ? [o/N] : ").strip().lower()
+        if answer not in ("o", "oui", "y", "yes"):
+            return
+    else:
+        print("\n[nogit] Aucun backup externe configuré.")
+        print()
+
+    new_path = input("  Chemin du dossier de backup externe : ").strip().strip('"')
+    if not new_path:
+        print("[nogit] Annulé.")
+        return
+
+    dest = Path(new_path)
+    if not dest.exists():
+        answer = input(f"  Ce dossier n'existe pas. Le créer ? [o/N] : ").strip().lower()
+        if answer not in ("o", "oui", "y", "yes"):
+            print("[nogit] Annulé.")
+            return
+        dest.mkdir(parents=True, exist_ok=True)
+
+    set_external_backup_dir(dest)
+    print(f"[nogit] ✓ Backup externe configuré → {dest}")
+
+
+def _run_local():
+    project_path = Path.cwd()
+    mode, _ = get_project_mode(project_path)
+    label = "[auto]" if mode == "auto" else "[manuel]"
+    print(f"\n  {project_path}  {label}")
+    _show_snapshots_and_diff(project_path)
+
+
+def _run_global():
+    registry = load_registry()
+
+    if not registry:
+        print("[nogit] Aucun projet enregistré.")
+        return
+
+    projects = [k for k in registry.keys() if not k.startswith("_")]
+    orphans = []
+    valid_projects = []
+    print()
+    for i, project in enumerate(projects, 1):
+        path = Path(project)
+        nogit_dir = path / ".nogit"
+
+        if not nogit_dir.exists():
+            print(f"  {i:>3}. {project}")
+            print(f"         [supprimé] le dossier .nogit n'existe plus — cette entrée sera retirée au prochain lancement")
+            orphans.append(project)
+            continue
+
+        valid_projects.append(project)
+        entry = registry[project]
+        if isinstance(entry, dict):
+            snapshots_paths = [Path(p) for p in entry.get("snapshots", [])]
+            count = len(snapshots_paths)
+        else:
+            snapshots_paths = _list_snapshots(path)
+            count = len(snapshots_paths)
+        mode, _ = get_project_mode(path)
+        mode_label = "[auto]" if mode == "auto" else "[manuel]"
+        label = f"{count} snapshot{'s' if count != 1 else ''}"
+        print(f"  {i:>3}. {project}  ({label})  {mode_label}")
+        for snap in snapshots_paths[:3]:
+            date_str = _format_date(Path(snap).stem)
+            print(f"         {date_str}")
+        if len(snapshots_paths) > 3:
+            print(f"         ... {len(snapshots_paths) - 3} snapshot(s) supplémentaire(s)")
+
+    if orphans:
+        for project in orphans:
+            del registry[project]
+        save_registry(registry)
+        projects = valid_projects
+
+    print()
+    choice = input("  > numéro du projet (ou Entrée pour annuler) : ").strip()
+    if not choice:
+        return
+
+    try:
+        idx = int(choice) - 1
+        if not (0 <= idx < len(projects)):
+            print("  Numéro invalide.")
+            return
+        _show_snapshots_and_diff(Path(projects[idx]))
+    except ValueError:
+        print("  Numéro invalide.")

nogit/cli.py

@@ -0,0 +1,97 @@
+"""NoGit CLI — git sans le bloat."""
+
+import sys
+import argparse
+from pathlib import Path
+from nogit import snapshot, backups, diff, automatic, restore
+
+
+_GPL_NOTICE = (
+    "NoGit  Copyright (C) 2026  Mehdi. A\n"
+    "This program comes with ABSOLUTELY NO WARRANTY; for details type `nogit show w'.\n"
+    "This is free software, and you are welcome to redistribute it\n"
+    "under certain conditions; type `nogit show c' for details.\n"
+)
+
+
+class _Parser(argparse.ArgumentParser):
+    def print_help(self, file=None):
+        print(_GPL_NOTICE)
+        super().print_help(file)
+
+
+def main():
+    parser = _Parser(
+        prog="nogit",
+        description="Git sans le bloat — snapshots ZIP + diff intelligent.",
+        formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=60),
+    )
+    subparsers = parser.add_subparsers(dest="command", metavar="commande")
+
+    # nogit snapshot
+    subparsers.add_parser(
+        "snapshot",
+        help="Crée un snapshot ZIP complet du dossier courant (mode manuel uniquement)."
+    )
+
+    # nogit backups
+    backups_parser = subparsers.add_parser(
+        "backups",
+        help="Liste les snapshots du dossier courant. Permet de lancer un diff ou un restore. --global : tous les projets de la machine. --external : configurer un backup secondaire."
+    )
+    backups_parser.add_argument(
+        "--global", dest="global_", action="store_true",
+        help="Liste tous les projets NoGit enregistrés sur la machine. Nettoie automatiquement les projets supprimés."
+    )
+    backups_parser.add_argument(
+        "--external", dest="external", action="store_true",
+        help="Configure le dossier de backup externe (disque secondaire, NAS...). Les snapshots y sont copiés automatiquement."
+    )
+
+    # nogit diff
+    diff_parser = subparsers.add_parser(
+        "diff",
+        help="Compare deux snapshots ZIP. Génère un dossier dans .nogit/diff/ avec diff.txt, summary.json et un .diff.json par fichier modifié."
+    )
+    diff_parser.add_argument("snap1", help="Premier snapshot ZIP.")
+    diff_parser.add_argument("snap2", help="Deuxième snapshot ZIP.")
+
+    # nogit automatic
+    subparsers.add_parser(
+        "automatic",
+        help="Active le watcher : surveille le dossier et crée un snapshot incrémental à chaque modification détectée."
+    )
+
+    # nogit manual
+    subparsers.add_parser(
+        "manual",
+        help="Désactive le watcher et repasse en mode snapshot manuel."
+    )
+
+    # nogit restore
+    restore_parser = subparsers.add_parser(
+        "restore",
+        help="Restaure le projet depuis un snapshot. Remonte automatiquement la chaîne si le snapshot est incrémental."
+    )
+    restore_parser.add_argument("index", type=int, help="Numéro du snapshot affiché dans 'nogit backups'.")
+
+    args = parser.parse_args()
+
+    if args.command == "snapshot":
+        snapshot.run()
+    elif args.command == "backups":
+        backups.run(global_=args.global_, external=args.external)
+    elif args.command == "diff":
+        diff.run(args.snap1, args.snap2)
+    elif args.command == "automatic":
+        automatic.run_automatic(Path.cwd())
+    elif args.command == "manual":
+        automatic.run_manual(Path.cwd())
+    elif args.command == "restore":
+        restore.run(args.index)
+    else:
+        backups.run()
+
+
+if __name__ == "__main__":
+    main()