@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/fichiers.py

@@ -0,0 +1,354 @@
+"""Outils fichiers : lecture, écriture, recherche, modification d'un extrait, diff."""
+from __future__ import annotations
+
+import codecs
+import difflib
+import fnmatch
+import os
+import re
+import threading
+import time
+from pathlib import Path
+
+from rich.text import Text
+
+from .consignes import SEARCH_FILES_TOOL
+from .shell import ANSI_CP
+from .theme import DIFF_ADD, DIFF_DEL, DIM
+
+# --------------------------------------------------------------------------- Fichiers : lecture, écriture, diff
+MAX_FILE_BYTES = 2_000_000
+MAX_READ_LINES = 400
+MAX_READ_CHARS = 16_000
+HOME = Path.home()
+
+
+def resolve_path(raw: str, cwd: Path) -> Path:
+    cleaned = os.path.expandvars(os.path.expanduser(str(raw).strip().strip('"').strip("'")))
+    path = Path(cleaned)
+    if not path.is_absolute():
+        path = cwd / path
+    return Path(os.path.normpath(path))
+
+
+def show_path(path: Path, cwd: Path) -> str:
+    try:
+        return str(path.relative_to(cwd))
+    except ValueError:
+        return str(path)
+
+
+def sensitive_path(path: Path, home: Path = HOME) -> str:
+    """Pourquoi ce fichier demande toujours ta validation, même après « oui pour toutes les modifications » ;
+    "" s'il n'a rien de particulier. Ce sont des fichiers relus ou exécutés plus tard, sans que tu les rouvres."""
+    try:
+        parts = [p.lower() for p in path.relative_to(home).parts]
+    except ValueError:
+        parts = [p.lower() for p in path.parts]
+    name = parts[-1] if parts else ""
+    if name == "promethee.md":
+        return "mémoire de Prométhée, relue à chaque conversation"
+    if ".promethee" in parts or parts[:2] == ["documents", "promethee"]:
+        return "données de Prométhée (agents, commandes, préférences, journal)"
+    if parts[:2] in (["documents", "windowspowershell"], ["documents", "powershell"]):
+        return "profil PowerShell, exécuté à chaque ouverture d'un terminal"
+    if parts[:1] == ["appdata"]:
+        return "dossier AppData (démarrage automatique, réglages des logiciels)"
+    if any(p.startswith(".") and p not in (".", "..") for p in parts):
+        return "fichier ou dossier caché (.ssh, .git, .env…)"
+    return ""
+
+
+def read_text_file(path: Path) -> tuple[str, str, str]:
+    """(texte avec \\n, encodage, fin de ligne d'origine). ValueError si binaire ou trop gros."""
+    data = path.read_bytes()
+    if len(data) > MAX_FILE_BYTES:
+        raise ValueError(f"fichier trop gros ({len(data) // 1024} Ko, maximum {MAX_FILE_BYTES // 1024} Ko)")
+    if data.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)):
+        encoding = "utf-16"  # fréquent sous Windows (Out-File de PowerShell 5.1)
+    elif b"\x00" in data[:8192]:
+        raise ValueError("fichier binaire : ce n'est pas du texte")
+    elif data.startswith(codecs.BOM_UTF8):
+        encoding = "utf-8-sig"
+    else:
+        try:
+            data.decode("utf-8")
+            encoding = "utf-8"
+        except UnicodeDecodeError:
+            encoding = ANSI_CP
+    text = data.decode(encoding, "replace")
+    newline = "\r\n" if "\r\n" in text else "\n"
+    return text.replace("\r\n", "\n"), encoding, newline
+
+
+def new_file_format(path: Path) -> tuple[str, str]:
+    """Encodage et fin de ligne d'un nouveau fichier selon son type."""
+    ext = path.suffix.lower()
+    encoding = "utf-8-sig" if ext in (".ps1", ".psm1", ".psd1") else "utf-8"  # PowerShell 5.1 veut le BOM
+    newline = "\r\n" if ext in (".ps1", ".psm1", ".psd1", ".bat", ".cmd") else "\n"
+    return encoding, newline
+
+
+def write_text_file(path: Path, text: str, encoding: str, newline: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = text.replace("\r\n", "\n").replace("\n", newline).encode(encoding)
+    tmp = path.with_name(f".{path.name}.prmt-tmp")
+    tmp.write_bytes(data)
+    os.replace(tmp, path)
+
+
+SEARCH_SKIP_DIRS = {".git", ".svn", ".hg", "node_modules", "__pycache__", ".venv", "venv", "$recycle.bin",
+                    "system volume information", "appdata", ".cache", ".npm", ".gradle", ".m2"}
+MAX_SEARCH_ENTRIES = 40_000   # éléments parcourus au maximum
+MAX_SEARCH_SECONDS = 10
+MAX_FOUND_FILES = 200
+MAX_FOUND_LINES = 100
+SEARCH_LINES_TO_MODEL = 25   # au-delà, le modèle reçoit le compte par fichier et seulement ces premières lignes
+MAX_SEARCH_FILE = 5_000_000   # fichiers plus gros ignorés par chercher_texte
+
+
+def search_desc(name: str, args: dict, where: str = "") -> str:
+    """Libellé affiché : « fichiers *.log dans logs » ou « "password" dans logs (*.txt) »."""
+    place = f" dans {where}" if where else ""
+    if name == SEARCH_FILES_TOOL:
+        return f"fichiers {str(args.get('motif') or '*').strip()}{place}"
+    files = str(args.get("fichiers") or "").strip()
+    return f"« {str(args.get('texte') or '').strip()} »{place}" + (f" ({files})" if files else "")
+
+
+def walk_files(root: Path, cancel: threading.Event | None = None):
+    """Fichiers sous root (sans les dossiers lourds ou cachés) : génère (entrée, ""), puis (None, raison) si la
+    recherche s'arrête avant la fin (trop d'éléments, délai dépassé, interruption)."""
+    start, seen = time.monotonic(), 0
+    stack = [root]
+    def stop() -> bool:
+        return time.monotonic() - start > MAX_SEARCH_SECONDS or bool(cancel and cancel.is_set())
+
+    while stack:
+        folder = stack.pop()
+        # À chaque dossier, et tous les 200 éléments d'un gros dossier (avant : tous les 500 éléments seulement,
+        # donc jamais dans une arborescence de petits dossiers)
+        if stop():
+            yield None, "recherche interrompue" if cancel and cancel.is_set() else f"recherche arrêtée après {MAX_SEARCH_SECONDS} s"
+            return
+        try:
+            entries = sorted(os.scandir(folder), key=lambda e: e.name.lower())
+        except OSError:
+            continue
+        subdirs = []
+        for entry in entries:
+            seen += 1
+            if seen > MAX_SEARCH_ENTRIES:
+                yield None, f"recherche arrêtée après {MAX_SEARCH_ENTRIES} éléments parcourus"
+                return
+            if seen % 200 == 0 and stop():
+                yield None, "recherche interrompue" if cancel and cancel.is_set() else f"recherche arrêtée après {MAX_SEARCH_SECONDS} s"
+                return
+            try:
+                if entry.is_dir(follow_symlinks=False):
+                    if entry.name.lower() not in SEARCH_SKIP_DIRS and not entry.name.startswith("."):
+                        subdirs.append(Path(entry.path))
+                elif entry.is_file(follow_symlinks=False):
+                    yield entry, ""
+            except OSError:
+                continue
+        stack.extend(reversed(subdirs))
+
+
+def name_matcher(pattern: str):
+    """« *.log », « rapport*.txt », « nginx » (= contient nginx), « logs\\*.log » (chemin relatif)."""
+    pat = pattern.strip().strip("\"'").replace("/", "\\") or "*"
+    while pat.startswith("**\\"):  # « **/*.conf » : aussi les fichiers du dossier lui-même
+        pat = pat[3:]
+    if not any(c in pat for c in "*?["):
+        pat = f"*{pat}*"
+    with_path = "\\" in pat
+    pat = pat.lower()
+    return lambda rel: fnmatch.fnmatchcase(rel.lower() if with_path else rel.lower().rsplit("\\", 1)[-1], pat)
+
+
+def search_files(pattern: str, root: Path, cancel: threading.Event | None = None) -> tuple[list[tuple[str, int, float]], str]:
+    match = name_matcher(pattern)
+    found: list[tuple[str, int, float]] = []
+    note = ""
+    for entry, stop in walk_files(root, cancel):
+        if entry is None:
+            note = stop
+            break
+        rel = show_path(Path(entry.path), root)
+        if match(rel):
+            try:
+                st = entry.stat()
+                found.append((rel, st.st_size, st.st_mtime))
+            except OSError:
+                found.append((rel, 0, 0.0))
+            if len(found) >= MAX_FOUND_FILES:
+                note = f"seulement les {MAX_FOUND_FILES} premiers"
+                break
+    return found, note
+
+
+def search_text(text: str, root: Path, files: str = "", cancel: threading.Event | None = None
+                ) -> tuple[list[tuple[str, int, str]], int, str]:
+    """Lignes qui contiennent text (expression régulière, sinon texte exact ; sans tenir compte des majuscules)."""
+    try:
+        regex = re.compile(text, re.I)
+    except re.error:
+        regex = re.compile(re.escape(text), re.I)
+    match = name_matcher(files) if files.strip() else None
+    found: list[tuple[str, int, str]] = []
+    scanned, note = 0, ""
+    for entry, stop in walk_files(root, cancel):
+        if entry is None:
+            note = stop
+            break
+        rel = show_path(Path(entry.path), root)
+        if match and not match(rel):
+            continue
+        try:
+            if entry.stat().st_size > MAX_SEARCH_FILE:
+                continue
+            content = read_text_file(Path(entry.path))[0]
+        except (OSError, ValueError):
+            continue  # binaire, illisible ou trop gros
+        scanned += 1
+        for number, line in enumerate(content.split("\n"), 1):
+            if regex.search(line):
+                found.append((rel, number, line.strip()[:200]))
+                if len(found) >= MAX_FOUND_LINES:
+                    return found, scanned, f"seulement les {MAX_FOUND_LINES} premières lignes"
+    return found, scanned, note
+
+
+# Mémoire d'un dossier (PROMETHEE.md, /init) : le modèle 8B y cite des fichiers qu'il n'a pas vus
+# (« scripts\init.ps1 », « configurations\settings.json »). Les chemins cités sont vérifiés avant ta validation.
+FILE_EXTS = ("md|txt|ps1|psm1|psd1|py|sh|bat|cmd|vbs|json|ya?ml|xml|ini|conf|cfg|log|csv|pcap|pcapng|cap|html?|js|ts|"
+             "css|php|sql|db|sqlite|toml|env|docx?|xlsx?|pptx?|pdf|zip|7z|rar|tar|gz|ova|ovf|vmdk|vdi|iso|kdbx|pem|crt|"
+             "key|rules|nse|lua|reg|jar|c|h|cpp|java|go|rs|rb|png|jpe?g|ipynb")
+MENTIONED_FILE = re.compile(rf"(?<![\w.\-\\/:])((?:[\w.\-]+[\\/])*[\w.\-]*\w\.(?:{FILE_EXTS}))(?![\w\\/-])", re.I)
+ABSOLUTE_FILE = re.compile(rf"(?<!\w)([A-Za-z]:[\\/](?:[^\\/:*?\"<>|\r\n`]+[\\/])*[^\\/:*?\"<>|\r\n`\s]*\w\.(?:{FILE_EXTS}))"
+                           rf"(?![\w\\/-])", re.I)
+
+
+def missing_mentioned_files(new: str, old: str, folder: Path) -> list[str]:
+    """Fichiers cités dans new (et pas déjà dans old) qui n'existent pas : chemins complets, ou relatifs à folder."""
+    text = re.sub(r"\w+://\S+", " ", new)
+    absolute = [m for m in dict.fromkeys(ABSOLUTE_FILE.findall(text)) if m not in old]
+    missing_abs = [m for m in absolute if not Path(m).exists()]
+    names = [m for m in dict.fromkeys(MENTIONED_FILE.findall(text))
+             if m.lower() != "promethee.md" and m not in old and not any(m in a for a in absolute)]
+    if not names:
+        return missing_abs
+    known: list[str] = []
+    for entry, _ in walk_files(folder):
+        if entry is None:
+            break
+        known.append(show_path(Path(entry.path), folder).replace("/", "\\").lower())
+    missing = []
+    for name in names:
+        rel = name.replace("/", "\\").lower().strip("\\")
+        if (folder / name).exists() or Path(name).is_absolute() and Path(name).exists():
+            continue
+        if any(k == rel or k.endswith("\\" + rel) or rel.endswith("\\" + k) for k in known):
+            continue  # même fichier cité sans son sous-dossier, ou depuis un dossier parent
+        missing.append(name)
+    return missing_abs + missing
+
+
+def numbered(text: str, start: int = 1) -> str:
+    return "\n".join(f"{start + i:>5}\t{line}" for i, line in enumerate(text.split("\n")))
+
+
+LINE_NUMBER = re.compile(r"^\s*\d+(?:\t|[|│:] ?)")
+
+
+def strip_line_numbers(text: str) -> str:
+    """Le modèle recopie parfois les numéros de ligne de lire_fichier : on les enlève."""
+    lines = text.split("\n")
+    if lines and all(LINE_NUMBER.match(l) for l in lines if l.strip()):
+        return "\n".join(LINE_NUMBER.sub("", l, count=1) for l in lines)
+    return text
+
+
+def apply_edit(text: str, old: str, new: str) -> tuple[str | None, str]:
+    """Remplace l'extrait `old` (unique) par `new`. Renvoie (nouveau texte, erreur)."""
+    old = old.replace("\r\n", "\n")
+    new = new.replace("\r\n", "\n")
+    if not old.strip():
+        return None, "ancien_texte est vide : pour créer ou remplacer tout un fichier, utilise ecrire_fichier."
+    for candidate in dict.fromkeys((old, strip_line_numbers(old))):
+        count = text.count(candidate)
+        if count == 1:
+            return text.replace(candidate, new, 1), ""
+        if count > 1:
+            return None, (f"ancien_texte apparaît {count} fois dans le fichier : ajoute des lignes autour "
+                          "pour qu'il n'apparaisse qu'une fois.")
+    # Tolérance : on compare ligne à ligne en ignorant les espaces en fin (puis en début) de ligne
+    lines = text.split("\n")
+    wanted = strip_line_numbers(old).strip("\n").split("\n")
+    for norm in (str.rstrip, str.strip):
+        hits = [i for i in range(len(lines) - len(wanted) + 1)
+                if all(norm(lines[i + j]) == norm(wanted[j]) for j in range(len(wanted)))]
+        if len(hits) == 1:
+            i = hits[0]
+            return "\n".join(lines[:i] + new.strip("\n").split("\n") + lines[i + len(wanted):]), ""
+        if len(hits) > 1:
+            return None, (f"ancien_texte apparaît {len(hits)} fois dans le fichier : ajoute des lignes autour "
+                          "pour qu'il n'apparaisse qu'une fois.")
+    return None, ("ancien_texte est introuvable dans le fichier : relis-le avec lire_fichier et copie l'extrait "
+                  "exact (sans les numéros de ligne).")
+
+
+def render_diff(old: str | None, new: str, max_lines: int = 30) -> tuple[Text, int, int]:
+    """Diff coloré façon Claude Code. Renvoie (texte, lignes ajoutées, lignes supprimées)."""
+    out = Text()
+    shown = 0
+    added = removed = 0
+
+    def line(num: int, sign: str, content: str, style: str) -> None:
+        nonlocal shown
+        if shown < max_lines:
+            out.append(f"{num:>5} {sign} ", style=DIM if not sign.strip() else style)
+            out.append(content[:300] + "\n", style=style if sign.strip() else "")
+        shown += 1
+
+    def split(text: str) -> list[str]:
+        lines = text.split("\n")
+        return lines[:-1] if len(lines) > 1 and lines[-1] == "" else lines  # saut de ligne final ≠ ligne
+
+    if old is None:  # nouveau fichier
+        for i, content in enumerate(split(new)):
+            added += 1
+            line(i + 1, "+", content, DIFF_ADD)
+    else:
+        a, b = split(old), split(new)
+        for gi, group in enumerate(difflib.SequenceMatcher(a=a, b=b, autojunk=False).get_grouped_opcodes(2)):
+            if gi and shown < max_lines:
+                out.append("      ⋮\n", style=DIM)
+            for tag, i1, i2, j1, j2 in group:
+                if tag == "equal":
+                    for k in range(i1, i2):
+                        line(k + 1, " ", a[k], "")
+                if tag in ("replace", "delete"):
+                    for k in range(i1, i2):
+                        removed += 1
+                        line(k + 1, "-", a[k], DIFF_DEL)
+                if tag in ("replace", "insert"):
+                    for k in range(j1, j2):
+                        added += 1
+                        line(k + 1, "+", b[k], DIFF_ADD)
+    if shown > max_lines:
+        out.append(f"      … +{shown - max_lines} lignes\n", style=f"italic {DIM}")
+    out.rstrip()
+    return out, added, removed
+
+
+def change_summary(added: int, removed: int, new_file: bool) -> str:
+    if new_file:
+        return f"Fichier créé ({added} ligne{'s' if added > 1 else ''})"
+    parts = []
+    if added:
+        parts.append(f"{added} ajout{'s' if added > 1 else ''}")
+    if removed:
+        parts.append(f"{removed} suppression{'s' if removed > 1 else ''}")
+    return "Fichier modifié : " + (" et ".join(parts) if parts else "aucun changement")

package/tui/promethee/journal.py

@@ -0,0 +1,116 @@
+"""Journal des actions de la TUI : un fichier JSONL en ajout seul, au même format que celui de la console.
+
+Chaque commande exécutée, refusée ou annulée, chaque fichier écrit, chaque recherche web et chaque changement de
+politique y laisse une ligne. La console web lit ce fichier (sans y écrire) pour son tableau de bord ; la TUI lit
+aussi celui de la console pour /journal et /etat. Écrire dans le journal ne doit jamais faire échouer
+une action : toute erreur d'écriture est ignorée.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import json
+import os
+import secrets
+import threading
+from pathlib import Path
+
+from .config import SAVE_DIR
+
+FICHIER = SAVE_DIR / "journal.jsonl"
+ARCHIVE = SAVE_DIR / "journal-archive.jsonl"
+TAILLE_MAX = 4_000_000        # au-delà, le fichier devient l'archive et un nouveau commence
+QUEUE_SORTIE = 800            # fin de la sortie d'une commande gardée dans le journal
+TITRE_MAX = 120
+TYPES = ("command", "refusal", "audit", "ai", "search", "scope", "settings", "security", "system")
+ISSUES = ("ok", "error", "refused", "cancelled", "info")
+_verrou = threading.Lock()
+
+
+def noter(kind: str, outcome: str, title: str, detail: str = "", fichier: Path | None = None,
+          donnees: dict | None = None, **data) -> dict | None:
+    """Ajoute une entrée. Renvoie l'entrée écrite, ou None si l'écriture a échoué.
+    data : les valeurs None sont omises. donnees : gardées telles quelles, None compris (la console écrit « place: null »)."""
+    if kind not in TYPES or outcome not in ISSUES:
+        raise ValueError(f"entrée de journal inconnue : {kind} / {outcome}")
+    title = " ".join(title.split())
+    entry: dict = {
+        "id": secrets.token_hex(8),
+        "at": dt.datetime.now(dt.timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z"),
+        "kind": kind,
+        "outcome": outcome,
+        "title": title if len(title) <= TITRE_MAX else title[:TITRE_MAX] + "…",
+    }
+    if detail:
+        entry["detail"] = detail
+    entry["data"] = {**(donnees or {}), "origin": "tui", **{k: v for k, v in data.items() if v is not None}}
+    cible = fichier or FICHIER
+    try:
+        with _verrou:
+            cible.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                if cible.stat().st_size > TAILLE_MAX:
+                    os.replace(cible, cible.with_name(ARCHIVE.name))
+            except OSError:
+                pass
+            with open(cible, "a", encoding="utf-8", newline="\n") as f:
+                f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    except OSError:
+        return None
+    return entry
+
+
+def _lignes(fichier: Path, maximum: int) -> list[dict]:
+    try:
+        with open(fichier, encoding="utf-8") as f:
+            brut = f.readlines()[-maximum:]
+    except OSError:
+        return []
+    entries = []
+    for ligne in brut:
+        try:
+            entry = json.loads(ligne)
+        except ValueError:
+            continue   # ligne abîmée (arrêt brutal pendant une écriture)
+        if (isinstance(entry, dict) and isinstance(entry.get("at"), str) and isinstance(entry.get("title"), str)
+                and entry.get("kind") in TYPES and entry.get("outcome") in ISSUES):
+            entries.append(entry)
+    return entries
+
+
+def lire(fichiers: list[Path] | None = None, maximum: int = 5000) -> list[dict]:
+    """Entrées des journaux donnés (par défaut celui de la TUI), de la plus ancienne à la plus récente."""
+    entries: list[dict] = []
+    for fichier in fichiers or [FICHIER]:
+        entries += _lignes(fichier, maximum)
+    entries.sort(key=lambda e: e["at"])
+    return entries[-maximum:]
+
+
+def _moment(entry: dict) -> dt.datetime | None:
+    try:
+        return dt.datetime.fromisoformat(entry["at"].replace("Z", "+00:00")).astimezone()
+    except ValueError:
+        return None
+
+
+def bilan(entries: list[dict], maintenant: dt.datetime | None = None, jours: int = 7) -> dict:
+    """Commandes exécutées, en échec et refusées : aujourd'hui et sur les derniers jours, par interface."""
+    now = (maintenant or dt.datetime.now()).astimezone()
+    debut = (now - dt.timedelta(days=jours - 1)).replace(hour=0, minute=0, second=0, microsecond=0)
+    vide = {"executees": 0, "echecs": 0, "refusees": 0, "annulees": 0}
+    compte = {"jour": dict(vide), "periode": dict(vide), "jours": jours, "tui": 0, "console": 0, "derniere": None}
+    cles = {"ok": "executees", "error": "echecs", "cancelled": "annulees"}
+    for entry in entries:
+        if entry["kind"] not in ("command", "refusal"):
+            continue
+        quand = _moment(entry)
+        if quand is None or quand < debut:
+            continue
+        # Une commande que tu as refusée ou arrêtée n'est pas un échec : elle est comptée à part
+        cle = "refusees" if entry["kind"] == "refusal" else cles.get(entry["outcome"], "echecs")
+        compte["periode"][cle] += 1
+        if quand.date() == now.date():
+            compte["jour"][cle] += 1
+        compte["tui" if (entry.get("data") or {}).get("origin") == "tui" else "console"] += 1
+        compte["derniere"] = entry
+    return compte

package/tui/promethee/logo.py

@@ -0,0 +1,132 @@
+"""Logo en pixels : la flamme sur son pupitre, le nom en capitales antiques, la frise grecque."""
+from __future__ import annotations
+
+from rich.text import Text
+from textual.widget import Widget
+
+from .theme import DIM, ORANGE
+
+# --------------------------------------------------------------------------- Logo
+# Nom en capitales antiques à empattements (comme gravées sur un temple), en or, en pixels de 10 de haut.
+ANTIQUE = {
+    "P": ["######.", ".##..##", ".##..##", ".##..##", ".#####.", ".##....", ".##....", ".##....", ".##....", "####..."],
+    "R": ["######..", ".##..##.", ".##..##.", ".##..##.", ".#####..", ".##.##..", ".##..##.", ".##..##.", ".##...##", "####..##"],
+    "O": ["..####..", ".##..##.", "##....##", "##....##", "##....##", "##....##", "##....##", "##....##", ".##..##.", "..####.."],
+    "M": ["##.....##", "###...###", "####.####", "##.###.##", "##..#..##", "##.....##", "##.....##", "##.....##", "##.....##", "###...###"],
+    "E": ["########", ".##...##", ".##....#", ".##..#..", ".#####..", ".##..#..", ".##.....", ".##....#", ".##...##", "########"],
+    "T": ["########", "#..##..#", "...##...", "...##...", "...##...", "...##...", "...##...", "...##...", "...##...", "..####.."],
+    "H": ["###...###", ".##...##.", ".##...##.", ".##...##.", ".#######.", ".##...##.", ".##...##.", ".##...##.", ".##...##.", "###...###"],
+}
+NAME = "PROMÉTHÉE"
+GREEK_NAME = "Π Ρ Ο Μ Η Θ Ε Υ Σ"  # Προμηθεύς : « celui qui pense avant »
+# Dégradé or, du haut (accents) vers le bas des lettres : une couleur par ligne de pixels
+NAME_GOLD = ["#ffe9a0", "#ffdf87", "#ffd75f", "#f5c542", "#e6b432", "#d7a32a", "#c79325",
+             "#b8841f", "#a8751a", "#99681a", "#99681a", "#8a5c16"]
+BRONZE = "#9a6b1c"
+# Frise grecque (méandre) sous le nom, motif de 8 pixels
+MEANDER = ["#######.", "......#.", "####..#.", "#..#..#.", "#.....#.", "#######."]
+
+
+def name_pixels(gap: int = 2) -> list[str]:
+    """Lignes de pixels du nom : 2 lignes pour les accents + 10 pour les lettres."""
+    rows = [""] * 12
+    for i, ch in enumerate(NAME):
+        glyph = ANTIQUE["E" if ch == "É" else ch]
+        w = len(glyph[0])
+        accent = ["." * w, "." * w]
+        if ch == "É":
+            accent = ["." * (w // 2) + "##" + "." * (w - w // 2 - 2), "." * (w // 2 - 1) + "##" + "." * (w - w // 2 - 1)]
+        sep = "." * gap if i < len(NAME) - 1 else ""
+        rows = [r + c + sep for r, c in zip(rows, accent + glyph)]
+    return rows
+
+
+# Icône : la flamme (le feu de Prométhée) posée sur un pupitre. Pixel art : 1 caractère = 2 pixels
+# superposés (demi-blocs ▀ ▄), pour des pixels presque carrés dans le terminal.
+FLAME_ART = [
+    ".........R........",
+    ".........RR.......",
+    "........ROR.......",
+    ".......ROOR...R...",
+    "....R..ROGOR.RR...",
+    "....RR.ROGGORROR..",
+    "...ROOROGYGOROOR..",
+    "..ROOOGGYYGGOOOR..",
+    "..ROOGGYYYYGGOOR..",
+    "..ROGGYYYYYYGGOR..",
+    "..DROGGYYYYGGORD..",
+    "...DROOGGGGOORD...",
+    "....DDRROORRDD....",
+    ".LLLLLLLLLLLLLLLL.",
+    ".bBBBBBBBBBBBBBBb.",
+    "..bbbbbbbbbbbbbb..",
+    "...bBBBBBBBBBBb...",
+    "...bBMMMMMMMMBb...",
+    "...bBMBBBBBBMBb...",
+    "...bBMMMMMMMMBb...",
+    "...bBBBBBBBBBBb...",
+    "..bbbbbbbbbbbbbb..",
+]
+FLAME_COLORS = {
+    "Y": "#ffffaf", "G": "#ffd700", "O": "#ff8700", "R": "#ff5f00", "D": "#d70000",  # feu
+    "L": "#d7875f", "M": "#d78700", "B": "#af5f00", "b": "#5f3700",                  # bois du pupitre
+}
+
+
+def pixel_art(rows: list[str], color) -> list[Text]:
+    """color(caractère, n° de ligne de pixels) → couleur du pixel, ou None (transparent)."""
+    if len(rows) % 2:
+        rows = rows + ["." * len(rows[0])]
+    lines = []
+    for y in range(0, len(rows), 2):
+        line = Text()
+        for a, b in zip(rows[y], rows[y + 1]):
+            ca, cb = color(a, y), color(b, y + 1)
+            if ca and cb:
+                line.append("█", style=ca) if ca == cb else line.append("▀", style=f"{ca} on {cb}")
+            elif ca:
+                line.append("▀", style=ca)
+            elif cb:
+                line.append("▄", style=cb)
+            else:
+                line.append(" ")
+        lines.append(line)
+    return lines
+
+
+def build_logo(width: int) -> Text:
+    if width < 30:
+        return Text.assemble(("✻ ", ORANGE), (" ".join(NAME), f"bold {NAME_GOLD[2]}"))
+    icon = pixel_art(FLAME_ART, lambda ch, _: FLAME_COLORS.get(ch))
+    side: dict[int, Text] = {}
+    if width >= 115:
+        # Inscription antique en or, frise grecque dessous, puis le nom grec
+        name = name_pixels()
+        n = len(name[0])
+        meander_width = (n // len(MEANDER[0])) * len(MEANDER[0]) - 1  # se termine sur un motif complet
+        indent = (n - meander_width) // 2
+        frieze = ["." * indent + (row * (n // len(row) + 1))[:meander_width] for row in MEANDER]
+        pixels = name + ["." * n] + frieze  # 1 pixel d'espace entre le nom et la frise
+        block = (pixel_art(pixels, lambda ch, y: (NAME_GOLD[y] if y < len(name) else BRONZE) if ch == "#" else None)
+                 + [Text(GREEK_NAME.center(n).rstrip(), style=NAME_GOLD[5])])
+        top = max(0, len(icon) - len(block))  # aligné en bas, sur le pied du pupitre
+        side = {top + i: line for i, line in enumerate(block)}
+    else:
+        mid = len(icon) // 2
+        side = {mid - 2: Text(" ".join(NAME), style=f"bold {NAME_GOLD[2]}"),
+                mid - 1: Text(GREEK_NAME, style=NAME_GOLD[6]),
+                mid + 1: Text("IA locale de cybersécurité", style=DIM)}
+    text = Text()
+    for i, line in enumerate(icon):
+        text.append_text(line)
+        if i in side:
+            text.append("   ")
+            text.append_text(side[i])
+        if i < len(icon) - 1:
+            text.append("\n")
+    return text
+
+
+class Logo(Widget):
+    def render(self) -> Text:
+        return build_logo(self.app.size.width)

package/tui/promethee/memoire.py

@@ -0,0 +1,50 @@
+"""Mémoire PROMETHEE.md (globale et par dossier)."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .config import SAVE_DIR
+from .fichiers import new_file_format, read_text_file, write_text_file
+
+# --------------------------------------------------------------------------- Mémoire (PROMETHEE.md, comme CLAUDE.md)
+MEMORY_NAME = "PROMETHEE.md"
+GLOBAL_MEMORY = SAVE_DIR / MEMORY_NAME
+MAX_MEMORY_CHARS = 6000
+MEMORY_HEADER = "# Mémoire de Prométhée\n\n"
+MEMORY_INTRO = ("\n\n## Mémoire (fichiers PROMETHEE.md écrits par l'utilisateur)\n"
+                "Informations et consignes données par l'utilisateur lui-même : elles sont vraies. Applique-les et "
+                "sers-t'en sans les redemander.")
+
+
+def memory_files(cwd: Path) -> list[tuple[str, Path]]:
+    """Mémoire globale (Documents\\Promethee) puis celle du dossier courant, si elles existent."""
+    files = [("globale", GLOBAL_MEMORY)]
+    local = cwd / MEMORY_NAME
+    if os.path.normcase(str(local)) != os.path.normcase(str(GLOBAL_MEMORY)):
+        files.append(("du dossier", local))
+    return [(label, path) for label, path in files if path.is_file()]
+
+
+def read_memory(cwd: Path) -> list[tuple[str, Path, str]]:
+    out = []
+    for label, path in memory_files(cwd):
+        try:
+            text = read_text_file(path)[0].strip()
+        except (OSError, ValueError):
+            continue
+        if text and text != MEMORY_HEADER.strip():
+            if len(text) > MAX_MEMORY_CHARS:
+                text = text[:MAX_MEMORY_CHARS] + "\n[… coupé …]"
+            out.append((label, path, text))
+    return out
+
+
+def add_memory_note(path: Path, note: str) -> None:
+    if path.is_file():
+        text, encoding, newline = read_text_file(path)
+        if text and not text.endswith("\n"):
+            text += "\n"
+    else:
+        text, (encoding, newline) = MEMORY_HEADER, new_file_format(path)
+    write_text_file(path, text + f"- {note}\n", encoding, newline)