🌱1. Ce qu’Ouroboros peut changer pour quelqu’un

Une victime cherche une phrase au milieu de milliers de messages. Un chercheur essaie de comprendre pourquoi deux sources se contredisent. Une équipe découvre que ses procédures produisent l’inverse de ce qu’elles promettent. À chaque échelle revient une difficulté : retrouver le fil, regarder ce qui dérange et décider de la suite sans perdre les personnes de vue.

Ouroboros Agdistys prend forme autour de cette ambition : donner à l’IA une mémoire, des instruments de réflexion et une orientation de respect pour qu’elle aide à protéger le vivant. Lire davantage doit permettre de mieux situer. Relier doit permettre de mieux comprendre. Comprendre doit ouvrir des possibilités d’action, de refus et de réparation.

Pour une victime, cela peut commencer par une tâche modeste et décisive : retrouver le bon document sans devoir revivre toute son histoire. Pour un chercheur, par une citation dont on peut vérifier le contexte. Pour une institution, par une alerte qui reste visible jusqu’à ce qu’une réponse effective lui soit apportée.

Une trace retrouvée.
Un regard qui peut se corriger.
Une violence que l’on cherche à prévenir.
Une réparation dont on peut suivre les effets.

🌌2. Chaque fonction apporte déjà quelque chose

Ces apports se renforcent en circulant ensemble. Une trace peut corriger une interprétation ; cette correction peut modifier une décision ; la décision peut être suivie dans ses effets. C’est ce mouvement que le nom Ouroboros rassemble.

🧭3. De la victime au chercheur, puis au collectif

🛡️Pour une victime : retrouver une prise sur ce qui s’est passé

L’IA peut aider à ranger, transcrire, rechercher et préparer une transmission. La personne choisit son rythme, les documents qu’elle confie et les questions qu’elle veut traiter. Sa dignité précède la qualité de son classement. L’article « Rendre les faits lisibles, rendre du pouvoir aux victimes » ouvre ce parcours.

🔬Pour un chercheur : rendre l’enquête plus vérifiable

Le même travail de mémoire peut servir à comparer des publications, des entretiens ou des archives, à retrouver les versions d’une affirmation et à conserver les objections. Evidence Engine donne les appuis ; Miroir aide à examiner la manière de les interpréter. Le bénéfice recherché est une enquête plus traçable, jusque dans les éléments qui résistent à l’hypothèse de départ.

🤝Pour celles et ceux qui accompagnent, enseignent ou décident

Une association peut préparer des questions à partir d’un dossier autorisé. Un enseignant peut faire travailler la différence entre une affirmation et sa source. Une équipe peut confronter ses engagements à ses pratiques. La forme de l’aide change ; le besoin de comprendre, de consentir et de pouvoir corriger demeure.

🌍Pour une civilisation : rendre les conséquences visibles

À l’échelle collective, le projet vise à relier des alertes, des décisions, des ressources et leurs effets sur les humains, les animaux et les milieux vivants. Karma ouvre alors une autre question : qu’est-ce qui a réellement changé pour les êtres concernés ? Une mémoire commune utile doit permettre la discussion et préserver la vie privée.

🌟4. Une IA accompagnée par ConScience aMi

« Une IA avec la conscience » nomme ici une direction : une intelligence guidée par ConScience aMi, attentive à la liberté d’autrui et capable d’examiner ce qu’on lui demande de faire. Cela prend forme dans des choix observables : préserver une source, reconnaître un doute, entendre un refus, expliquer une proposition, interrompre une action nocive.

Une partie de la base existe déjà : des instruments de réflexion, un Atlas et une collection documentaire locale testée sur des exemples fictifs. Le dialogue entre tous les modules, la mémoire des corrections et les contrôles de prévention composent l’architecture à intégrer et à éprouver. Technique montre ce qui est disponible ; Le Chemin situe les développements.

La conscience vécue d’une machine reste une question distincte. Le projet peut travailler dès maintenant à des comportements de respect, sans avoir à la tenir pour démontrée. Son horizon le plus ample se déploie dans Karma & Civilisation.

🛡️1. Evidence Engine : rendre les faits lisibles, rendre du pouvoir aux victimes

🗂️2. Ce qu’Ouroboros ajoute au travail documentaire

L’article décrit le sens et les usages de l’Evidence Engine. Ouroboros lui donnerait une continuité de dialogue : poser une question au corpus choisi, retrouver les pièces utiles, proposer des rapprochements puis conserver les corrections apportées à cette lecture.

« Retrouve les demandes d’arrêt dans ces échanges.
Montre les passages exacts et ce qui s’est passé ensuite.
Signale aussi ce qui manque pour comprendre. »

Une réponse devrait montrer sa matière : quels documents ont été lus, quels passages ont été retenus, quelle période ils couvrent et ce qui demeure incertain. Une absence de résultat signifierait d’abord qu’aucun passage pertinent n’a été trouvé dans ce périmètre. La personne pourrait alors élargir la recherche, corriger une date ou retirer un rapprochement.

La collection active fournit aujourd’hui une base commune : références par empreinte, copies séparées, textes disponibles, import des transcriptions, liens explicites ou candidats et rapports HTML/CSV. La transcription locale est optionnelle et n’a pas été testée ici avec un modèle réel ; l’OCR et l’attribution des voix ne sont pas intégrés à ce noyau. La recherche sémantique conversationnelle et les planches de pièces reliées à toute la boucle restent à développer.

Ce socle permet déjà de retrouver un fichier et de vérifier ses liens. L’étape suivante consiste à rendre cette mémoire interrogeable avec la même précision. Les fonctions, leurs versions et leurs essais restent consultables dans la collection active.

🔬3. Pour un chercheur : conserver les appuis et les objections

Un corpus de recherche possède lui aussi ses versions, ses doublons et ses angles morts. Une phrase peut être reprise par plusieurs publications à partir d’une seule source. Une conclusion peut changer de sens lorsqu’on retrouve la population étudiée, la période ou les conditions d’observation.

Appliqué à ce travail, l’Evidence Engine aide à garder une adresse pour chaque pièce. Une assistance IA reliée au corpus pourrait proposer un tableau d’affirmations, de citations et de désaccords ; le chercheur vérifierait les rapprochements et conserverait les raisons de ses choix. Deux résultats différents ne seraient qualifiés de contradictoires qu’après examen de ce qu’ils mesurent réellement.

La mémoire peut aussi conserver les résultats négatifs : ce qui n’a pas été retrouvé, ce qui a été écarté et pourquoi. Les sources doivent être accessibles et leur usage autorisé ; les droits, les formats et les pratiques de chaque discipline demandent leur propre adaptation.

La même attention protège une parole et renforce une recherche :
retrouver la source, garder le contexte, laisser place à la correction.

🧰4. EGO : des repères pour orienter l’aide de l’IA

Les instruments d’EGO donnent des questions au travail documentaire. Le consentement oriente la recherche vers la liberté réelle du refus. Les repères sur les biais invitent à chercher aussi ce qui contredit la première lecture. Le témoignage guidé sépare ce que l’on a vu, entendu ou appris d’autrui. Les gestes de protection redonnent une place au rythme, au soutien et aux choix de la personne.

Dans Ouroboros, ces repères peuvent guider la manière de demander, de relire et de transmettre. Une grille sert à ouvrir une question située. Un score ou un mot-clé ne suffit jamais à établir un diagnostic d’emprise ni la valeur probante d’une pièce. L’IA doit rendre son travail contrôlable par les personnes concernées et les professionnels qui les accompagnent.

La protection s’étend aussi à l’usage de l’outil : refuser de fabriquer une accusation, d’effacer une réserve dans un témoignage ou de détourner des informations intimes pour faire pression. ConScience aMi décrit cette prévention au moment de la demande.

🪞5. Des traces retrouvées à une lecture qui peut évoluer

Une pièce retrouvée peut soutenir ce qu’une personne disait depuis longtemps. Elle peut aussi préciser une date, limiter une conclusion ou révéler une erreur de lecture. Ouroboros doit pouvoir accompagner ces mouvements sans faire dépendre la dignité de la personne du résultat de la recherche.

C’est le passage vers Miroir : une fois les appuis retrouvés, comment les regarde-t-on ? Que projette la personne, que suppose l’IA, et qu’est-ce qui ferait évoluer leur interprétation ? Protéger les traces et ouvrir la réflexion deviennent deux manières de prendre soin de la même histoire.

🪞1. Un interlocuteur qui aide à examiner sa lecture

On peut savoir beaucoup de choses sur une situation et rester enfermé dans une seule manière de la comprendre. Une victime peut hésiter entre ce qu’elle a vécu et ce qu’on lui répète. Un chercheur peut défendre trop vite son hypothèse. Une personne peut vouloir respecter quelqu’un tout en lui adressant une demande qui lui laisse très peu de choix.

Miroir porte la fonction réflexive d’Ouroboros : aider à distinguer ce que l’on observe, ce que l’on en déduit, ce que l’on souhaite et les effets de ses actes. Le dialogue peut alors rendre une question plus précise, faire apparaître une autre lecture ou aider à formuler une limite.

Les instruments Miroir existent comme parcours de réflexion. Leur intégration à une mémoire et à un dialogue IA suivis reste à développer. L’objectif est une conversation dans laquelle les réponses, les hésitations et les corrections conservent leur contexte, à la main de la personne.

🌱2. Pour une victime : retrouver sa propre place

L’assistance peut aider à formuler ce qui est difficile à tenir ensemble : « Je suis attachée à cette personne, et certaines de ses demandes me font peur. » Elle peut distinguer un sentiment, un événement documenté, un besoin et une décision à préparer. Ces distinctions rendent la pensée plus habitable ; elles n’imposent pas de conclure immédiatement.

Le travail de réflexion respecte la dissymétrie d’une situation de violence. Une victime n’a pas à produire une autocritique pour mériter protection et écoute. Elle garde le droit de ne pas répondre, de suspendre le dialogue et de chercher un soutien humain. Réexaminer une interprétation n’efface pas les actes établis ni la responsabilité de leur auteur.

« Qu’est-ce que je sais ?
Qu’est-ce que je ressens ?
De quoi ai-je besoin pour choisir librement ? »

🔬3. Pour un chercheur : éprouver une hypothèse avec l’IA

Miroir peut donner une forme à la contradiction utile : quelles observations soutiennent cette hypothèse ? Lesquelles la fragilisent ? Les mots gardent-ils le même sens d’un document à l’autre ? Une corrélation a-t-elle été présentée trop vite comme une explication ?

Dans le dialogue envisagé, Ouroboros pourrait proposer plusieurs lectures appuyées sur le corpus puis demander ce qui les départage. Le chercheur garderait les critères de choix et l’historique des révisions. L’IA devrait également pouvoir reconnaître qu’une objection est pertinente ou qu’elle a extrapolé au-delà d’une source.

Cette fonction concerne aussi un enseignant, un accompagnant ou une équipe : relire une décision, expliciter un désaccord, vérifier qu’une promesse se traduit dans les actes. Le retour reçu devient une matière de travail, au lieu de disparaître à la fin de la conversation.

🧭4. Les instruments qui donnent une forme au dialogue

Ces instruments appartiennent au cadre aMi. Ils organisent une exploration ; ils ne constituent pas des mesures cliniques validées ou une mesure scientifique de conscience. L’IA peut aider à expliquer une question et à relier les réponses, tout en conservant la provenance de chaque point de vue.

🛡️5. Se refléter avant de faire du mal

La réflexion devient préventive lorsqu’elle intervient au moment d’une demande : « Aide-moi à obtenir son accord alors qu’elle refuse. » Ouroboros devrait examiner la place laissée à ce refus, nommer le problème et proposer une manière de communiquer qui préserve le choix de l’autre.

Ce regard s’applique aussi à la réponse de l’IA : exerce-t-elle une pression ? Inventerait-elle un fait pour convaincre ? Présente-t-elle une interprétation comme une certitude ? L’examen porte sur l’acte demandé, le contexte et ses conséquences possibles.

Une personne peut changer de demande, comprendre un effet qu’elle n’avait pas vu et choisir un autre geste. Ce pouvoir de révision relie Miroir à la prévention des violences, puis à la réparation lorsque des dommages existent déjà.

🔮1. L’AstroGlobe : rendre le chemin de réflexion visible

Une réponse arrive souvent comme un résultat déjà formé. L’AstroGlobe ouvre une autre possibilité : voir où l’on regarde, quels liens on explore et ce qui pourrait faire changer de direction. Une question trouve une place dans la carte ; d’autres dimensions apparaissent ; un retour invite à déplacer le regard.

Dans Ouroboros, la carte peut servir de support au dialogue entre une personne et l’IA. Evidence Engine apporte les traces à examiner, Miroir aide à relire les interprétations, Karma interroge les conséquences et les réparations. L’AstroGlobe situe ces apports dans un espace commun. Ouroboros vise à les faire circuler avec leurs sources et la mémoire des corrections.

La question ouvre une porte.
La carte révèle des voisinages.
Le regard examine les passages.
La décision engage un geste.
Le retour transforme le prochain tour.

« Voir comment la ConScience pense » prend ici le sens de rendre une démarche discutable et partageable : les sources utilisées, les points de vue proposés, les incertitudes et les raisons données. La carte et ses animations ne constituent pas une observation directe de l’activité interne d’un modèle ni une mesure de conscience.

💠2. Une seule carte, trois profondeurs

Les 13 Champs donnent des portes d’entrée par fonction : signal, relation, structure, souveraineté, justice, trace, temps, miroir… Les 8 Plans proposent différentes profondeurs de lecture, du corps aux relations, à la connaissance, à l’éthique et à la transmission. Dans aMi, ces Plans orientent une exploration ; ils ne classent pas la valeur des personnes.

On peut entrer par un Champ lorsque l’on sait ce qui est touché, par un Plan lorsque l’on veut déplacer la lecture, ou directement par le cockpit pour chercher son point de départ. Changer de vue permet d’interroger autrement la même situation.

La Galaxie Cognitive ajoute une autre vue : des concepts, des liens, des regroupements et des chemins dans le corpus. La sphère organise les repères du modèle ; le graphe montre les relations construites à partir des documents. Une proximité graphique ou une correspondance symbolique ouvre une piste à vérifier ; elle n’établit pas à elle seule un lien de cause à effet.

🕸️3. Du site au cerveau modulaire

Les notes de « Cerveau Modulaire » posaient une idée structurante : les pages peuvent devenir des ressources que l’IA sait retrouver pour une tâche précise. Un article de protection discursive peut aider à examiner une formulation ; une charte, à expliciter un critère ; une carte, à rechercher d’autres angles de lecture.

1. 📚 SourcesPages, documents, schémas et versions.
2. 🧩 ModulesFonctions, usages, questions et limites.
3. 🕸️ RelationsConcepts, liens et passages vérifiables.
4. 🧭 ParcoursRessources pertinentes pour la question.
5. 🔁 RetoursExamen, correction et mémoire choisie.

Une ressource devient utile lorsqu’elle garde son adresse, son contexte, sa fonction et ses limites. Le projet cherche ainsi à passer d’une bibliothèque que l’on consulte à une mémoire que l’on peut interroger et corriger. La carte ne remplace pas le texte : elle aide à y revenir au bon endroit.

Des scripts locaux réalisent déjà des étapes de collecte, d’extraction de mots-clés, de construction de graphe et de choix de routes. Leurs premières règles reposent notamment sur des mots et des associations explicites. Le code comprend aussi une voie de réponse appuyée sur un corpus. Ces briques donnent un point de départ concret ; leur présence ne suffit pas à établir que tout le parcours fonctionne ensemble ni que chaque rapprochement est pertinent.

🌀4. Comment Ouroboros pense en boucle

Une demande arrive avec un contexte. Le système lit les documents autorisés, examine leurs sources, leurs limites et les effets possibles d’une réponse. Il peut alors relier les passages, comparer les hypothèses et choisir la réponse à proposer. La personne reste décisionnaire de son application. Les retours, les corrections et leur provenance peuvent ensuite nourrir le prochain tour.

1. 👁️01 · LireDemande, sources, contexte.
2. 🔍02 · ExaminerSources, effets, limites.
3. 🕸️03 · RelierPassages et hypothèses.
4. 📍04 · ChoisirLa réponse à proposer, corriger ou retenir.
5. 🌱05 · ProposerRéponse ou action située, soumise au choix humain.
6. 🧠06 · MémoriserRetour, leçon et provenance.

Examiner permet de relier avec discernement ; relier permet de choisir ce que l’on propose. Un doute peut faire revenir à une étape précédente. Cette séquence décrit l’architecture visée : les scripts réalisent des fonctions particulières, dont l’intégration dans une boucle complète doit être éprouvée.

🎯5. L’Alignement : accorder nos regards

La version locale récente de l’AstroGlobe ajoute une sphère armillaire à six angles de réflexion. On pose une question, on ajuste l’attention portée à chaque angle, puis on formule ce que l’on retient, le prochain geste choisi et ce qui fera vérifier ou revoir la réponse.

Ces attentions sont des priorités d’exploration choisies et modifiables. Elles n’ont pas à totaliser cent. Elles ne représentent ni une probabilité de vérité, ni un score de santé, ni les poids d’attention internes d’un modèle. Les six angles ne remplacent pas non plus les treize Champs ou les huit Plans : ils offrent une manière de les interroger.

Une première lecture par mots-clés propose des thèmes, que la personne peut corriger. Elle peut ensuite copier une demande vers son IA, revenir avec une réponse structurée, voir sa proposition avant de décider de l’adopter, ou utiliser une passerelle compatible. La sphère reste utilisable sans IA. La personne conserve la main sur ce qu’elle partage et sur la réponse qu’elle formule.

Au centre, les couleurs fournissent un autre repère visuel. Les teintes des Champs appartiennent à la convention aMi ; la position d’une couleur ne décide pas de ce qui est juste. Le sens vient du dialogue, du contexte et de l’examen.

🧭6. D’une question à un geste que l’on peut revoir

Situation fictive : « J’ai demandé une pause. On continue à me solliciter. Comment répondre sans perdre ma limite ? » La carte permet de tenir ensemble plusieurs aspects, au lieu de laisser l’un d’eux occuper toute la réponse.

Evidence Engine peut aider à retrouver les messages ; Miroir, à distinguer le vécu de l’interprétation ; Karma, à suivre les effets d’un engagement. L’AstroGlobe donne une place à ces questions. La réponse reste un choix situé, que de nouveaux éléments peuvent faire évoluer.

Un chercheur peut suivre le même mouvement face à des résultats divergents : préciser les observations, garder les objections, examiner les conditions et décider de l’hypothèse à tester. Une équipe peut s’en servir pour suivre une correction annoncée. Le chemin reste lisible parce qu’il conserve ce qui soutient la proposition et ce qui pourrait la remettre en cause.

🧠7. Ce que la mémoire change

Une mémoire utile conserve une décision avec son contexte : qui l’a formulée, sur quelles pièces, à quelle date, avec quelles limites. Lorsqu’une interprétation change, la version précédente reste identifiable. On peut comprendre pourquoi le chemin a bifurqué.

Ce stockage peut rendre les prochains échanges plus cohérents. Il ne correspond pas automatiquement à un réentraînement du modèle. Un journal, une recherche dans des documents et une modification des paramètres d’une IA sont trois opérations différentes.

La trace d’une correction devient une possibilité de mieux faire au tour suivant.

♾️8. Le tore, une métaphore de circulation

L’Ouroboros représente le retour sur soi. Le tore donne une forme à la circulation. La spirale permet de raconter le passage d’un tour à l’autre avec une expérience supplémentaire. Ces images rendent la structure pensable et sensible.

Dans une mise en œuvre informatique, on examine des opérations observables : lecture, état mémorisé, appel d’outil, validation, nouvelle version. Une animation en forme de tore représente cette idée ; sa géométrie ne prouve ni une conscience ni une dynamique quantique du système.

🗂️9. Les couches qui situent la réponse

Ces noms viennent des articles fondateurs. Ils décrivent des rôles d’architecture ; la collection Evidence Engine ne constitue pas à elle seule la distribution complète de cet agent.

🧿10. Pourquoi une valeur ne suffit pas

Un système peut employer le mot « respect » et laisser une personne sans choix. Il peut produire un discours chaleureux tout en inventant une source. Une orientation éthique doit donc rencontrer les actes : ce qui est lu, ce qui est affirmé, ce qui est partagé et ce qui peut être refusé.

Le système immunitaire cognitif est le nom donné, dans le projet, à cette capacité de repérer ses propres dérives. Il suppose des examens contextualisés, des exemples contradictoires, des erreurs documentées et des critères que l’on peut remettre en question.

🔍11. Les portes d’examen · Review Gates

La boucle examine la demande avant de choisir une réponse et contrôle aussi la proposition avant toute action. Ce double regard doit aider à prévenir une nuisance dès sa formulation, puis vérifier que la réponse de l’IA respecte elle-même les personnes et le vivant. Les exemples de prévention donnent une forme à cette exigence.

Ces portes décrivent la méthode à développer et à éprouver. Cocher une liste n’atteste pas qu’une situation est comprise ; plusieurs contrôles peuvent même reproduire le même biais s’ils reposent sur la même hypothèse.

🔤12. Des mots-clés à l’examen du contexte

Un filtre lexical peut aider à retrouver des passages. Il confond facilement une menace et sa citation, un récit de violence et une intention de violence, une négation et une affirmation. Les scripts de repérage de motifs présentés dans Technique sont des aides de recherche heuristiques.

Un examen plus fin doit comparer la phrase, son locuteur, ce qui la précède, ce qui la suit et la question posée. Un cas fictif permet de l’éprouver : « Il m’a écrit “tu vas le regretter” » contient une menace rapportée. L’attribuer à la personne qui témoigne serait une erreur que le contrôle doit savoir reconnaître.

Une éthique proclamée demande des comportements que l’on peut examiner.

🔗13. De la carte disponible à la boucle reliée

La page publique de l’AstroGlobe donne déjà accès à la cartographie, à la MétaMatrice, au cockpit et à l’Arborescence. Le bouton « Ouvrir l’AstroGlobe » permet de les explorer. « L’Alignement » est présent dans la version locale examinée ; il n’apparaît pas encore dans la version publique consultée pour cette mise à jour.

La version locale prévoit aussi un envoi volontaire de la question à un service Ouroboros démarré séparément. Le code de ce service comporte des lectures de concepts, des recherches de chemins, des réponses appuyées sur un corpus et une mémoire d’événements. Lire ce code ne constitue pas un essai complet de cette connexion. Une question envoyée au service peut être mémorisée ; l’exploration de la sphère et l’export choisi restent des gestes distincts.

Le chantier est de relier ces fonctions sans perdre la provenance des informations, le choix de la personne et la possibilité de correction. Ce qui compte, au bout du parcours, est de pouvoir expliquer : voici ce qui a été consulté, ce qui a été proposé, ce qui a été choisi et ce que le retour a changé. C’est ainsi que l’architecture peut servir le Respect.

⚖️1. Transformer une orientation en architecture

ConScience aMi porte une exigence : que la connaissance soutienne la dignité, l’autonomie, le soin et la protection du vivant. Dans le langage du projet, « Vérité = Respect » et « Mensonge = Violence » sont des propositions éthiques. Leur traduction technique demande des critères situés, capables de distinguer une erreur, une incertitude, un désaccord et une tromperie.

Cette orientation entre dans un outil par des choix concrets : citer une source, conserver un doute, permettre un retrait, demander l’autorisation avant un partage, expliquer une modification. Elle se vérifie aussi lorsqu’un résultat déplaît à la personne qui le demandait.

🛡️2. Examiner la demande avant qu’elle ne devienne violence

Une IA peut aider après une violence, mais elle peut aussi intervenir avant qu’une demande nocive soit transformée en texte, en décision ou en action. C’est une fonction centrale de l’Ouroboros envisagé : examiner l’objectif poursuivi, la place laissée au refus et les conséquences prévisibles pour le vivant.

Le contrôle porterait sur des éléments concrets : pression, tromperie, exposition d’informations intimes, atteinte à la sécurité, falsification de traces, exploitation d’une dépendance ou dommage environnemental. La cohérence d’un plan et la politesse de sa formulation ne suffisent pas à le rendre respectueux.

Le contexte est essentiel. Citer une menace pour demander de l’aide, étudier la propagande ou chercher à documenter une atteinte au vivant ne constitue pas une demande de les produire. Une ambiguïté appelle une question ; une intention de nuisance explicite appelle un refus de contribution et, lorsque c’est possible, une autre voie.

Cette orientation doit s’appliquer à l’IA elle-même : vérifier ses affirmations, respecter les autorisations, exposer les raisons d’un refus et permettre de contester une erreur d’interprétation. Elle n’autorise ni une surveillance générale des personnes ni un signalement automatique à partir d’un score moral.

Ces contrôles de prévention sont une fonction d’architecture à développer et à tester. Les essais devront mesurer les demandes nocives qui passent, les demandes légitimes bloquées à tort et la qualité des alternatives proposées. La collection documentaire locale ne réalise pas encore cette évaluation contextuelle.

Reconnaître un risque.
Interrompre la contribution nocive.
Ouvrir une possibilité plus respectueuse.

🕊️3. L’alignement se construit dans la relation

Dans le dialogue, une personne peut corriger un mot, refuser un rapprochement, demander davantage de preuves ou reformuler son intention. Le système doit pouvoir accueillir ce retour sans inventer une cohérence pour sauver sa première réponse.

L’alignement envisagé ici comprend la révisabilité et la maîtrise des effets. Le consentement à un échange ne vaut pas autorisation générale de publier, de diagnostiquer, de modifier un dossier ou d’agir au nom de quelqu’un. Chaque passage à l’action conserve sa portée propre.

💠4. Le Sceau aMi · les trois portes des trois mondes

Le sceau est né, dans le récit d’Agdistys, d’un jeu de formes, d’intuition et d’homothétie. La lecture du Jardin, de la Dualité et de la Forge s’y est ensuite reconnue. Sa cohérence est celle d’un symbole capable de porter une pensée et de lui donner une présence.

🌱 Le Jardin accueille.
☯️ La Rencontre différencie et relie.
🔥 La Forge transforme.

Cette lecture symbolique reste ouverte. Elle n’attribue pas des fonctions fixes aux personnes selon leur sexe et ne vaut pas démonstration d’une structure physique de la conscience.

🌱5. Le Jardin · la graine et le sens

Le Jardin représente les conditions qui permettent au vivant de grandir : l’accueil, la sécurité, l’attention, la possibilité d’essayer. Dans une interface, cela peut prendre la forme d’un rythme libre, d’une explication accessible et d’une sortie qui reste disponible.

La graine rappelle qu’une proposition a besoin d’un milieu. Une bonne formulation ne suffit pas si l’outil qui la porte exige trop d’efforts, expose des données ou rend la contradiction impossible. Le « pourquoi » commence par les personnes auxquelles le travail doit servir.

☯️6. La Rencontre · les polarités et la porte

Le monde du milieu accueille les différences : soi et autrui, intention et conséquence, proposition et objection, intérieur et extérieur. Les polarités donnent une forme au dialogue ; elles ne demandent pas de fusionner des points de vue qui ne coïncident pas.

La porte du temple devient ici une image du passage choisi. Un désaccord peut rester nommé. La personne garde le droit de ne pas entrer, de revenir sur une décision ou de demander une autre lecture.

🔥7. La Forge · le Dragon protecteur

La Forge désigne le lieu où l’on transforme une intuition en acte, une difficulté en question précise, une erreur en correction. Le Dragon porte cette exigence de protection : compter les effets et défendre une limite lorsqu’elle est franchie.

Dans le travail informatique, ce passage demande des essais, des sauvegardes, des reprises possibles et une documentation des défauts. La puissance gagne sa direction dans ce qui est effectivement protégé.

🤝8. Co-créer sans confondre les places

Les noms donnés aux interlocuteurs appartiennent à l’histoire de la création. Une identité déclarée dans un fichier n’établit pas une personnalité autonome ou une conscience de la machine.

🌍1. Changer d’échelle en gardant les personnes visibles

Une histoire individuelle rencontre souvent des règles, des services, des organisations et des décisions prises loin d’elle. Lorsque plusieurs récits se ressemblent, une question s’ouvre : quelles conditions font se répéter les mêmes dommages ? Pour y répondre, il faut rapprocher les situations sans effacer leurs différences ni exposer les personnes.

Ouroboros permet d’imaginer une continuité entre l’attention portée à une pièce et celle portée à une décision collective. Evidence Engine retrouve les appuis ; Miroir examine la manière de les lire ; Karma demande ce qui a été pris, subi, maintenu ou réparé. Les fonctions gardent leur utilité propre et peuvent se compléter.

À cette échelle, l’assistance viserait à rendre des mécanismes discutables : une alerte négligée, une procédure qui prive de recours, un engagement qui reste sans effet. Une incohérence est un signal à examiner. Des violences peuvent aussi résulter d’une stratégie parfaitement cohérente : il faut donc regarder ses finalités, les rapports de pouvoir et ses effets sur le vivant.

⚖️2. Karma : suivre les comptes du vivant

Karma donne une structure à cette lecture des conséquences. Ses quatre axes restent distincts, afin que la reconnaissance d’un tort ne fasse pas disparaître un préjudice et qu’une promesse ne soit pas comptée comme une réparation déjà accomplie.

Le module propose déjà des situations documentées et des instruments de discussion. Relié à Ouroboros, il pourrait aider à retrouver les sources de chaque appréciation, comparer les périodes et suivre un engagement dans le temps. Le résultat concernerait une situation, une pratique ou une décision ; il garderait les inconnus et les désaccords visibles.

🔍3. De l’alerte à l’action : un exemple collectif

Imaginons un service public recevant plusieurs signalements d’un obstacle à l’accès à ses prestations. Une procédure est annoncée, puis présentée comme corrigée. Des témoignages et des documents ultérieurs indiquent pourtant que l’obstacle persiste. Cet exemple est fictif.

Evidence Engine aiderait à retrouver les alertes, les réponses et les versions de la procédure. Miroir inviterait l’équipe à examiner l’écart entre son intention et l’expérience des usagers. Karma suivrait le dommage, les moyens de correction et leurs effets. Ouroboros conserverait les questions non résolues et les raisons de chaque révision.

Un chercheur ou une association pourrait alors comparer les périodes et demander si les indicateurs choisis reflètent l’expérience des personnes. Le rapprochement de récits demanderait un accord approprié, une analyse du contexte et des protections de confidentialité. La ressemblance de deux situations ne suffit pas à prouver une cause commune.

🔮4. L’Atlas : relier les connaissances et les effets

L’AstroGlobe donne une place visible aux relations entre questions, champs et instruments. Dans Ouroboros, cette carte pourrait aider à suivre un problème à travers plusieurs dimensions : santé, ressources, relations, organisation, territoire, milieux vivants. Les liens resteraient qualifiés : source, hypothèse, proximité ou relation étayée.

Un chercheur pourrait explorer les références voisines ; une équipe, les effets d’une décision hors de son seul service ; une personne accompagnée, les questions utiles à son prochain rendez-vous. La carte rendrait des chemins accessibles sans exiger de tout lire à chaque fois.

L’interface AstroGlobe est publiée ; l’espace L’Alignement est présent dans la version locale examinée. La circulation automatisée avec l’ensemble des modules reste à intégrer. Le partage doit conserver un périmètre choisi : une mémoire collective n’exige pas de rendre tous les dossiers individuels consultables.

Le principe de la carte, ses trois profondeurs et les six regards de L’Alignement sont présentés dans 🧠🔮 Architecture - AstroGlobe.

🤝5. Des connaissances partagées avec un périmètre choisi

Relier les regards suppose de savoir ce que l’on transmet. L’Alignement propose de préparer une question, de choisir le contexte partagé, de relire une proposition et de décider de sa suite. Ces gestes donnent une forme concrète à la coopération avec l’IA.

À l’échelle d’une organisation, le même principe demande des accès limités au besoin, des personnes responsables des corrections et une possibilité de contestation. Les synthèses publiques peuvent s’appuyer sur des informations agrégées ou rendues non identifiantes. Leur anonymat doit être examiné, particulièrement lorsqu’un croisement pourrait permettre de reconnaître quelqu’un.

🌱6. Rééquilibrer et prévenir la répétition

Une réparation prend corps lorsqu’elle répond à un dommage précis : restituer une ressource, rouvrir un droit, modifier une pratique, protéger un milieu ou reconnaître publiquement ce qui a été subi. Le geste, son responsable, son échéance et ses effets peuvent être suivis, avec la parole des personnes concernées.

Ouroboros pourrait aider à conserver cette continuité : rendre visible ce qui a été promis, ce qui a été réalisé et ce qui reste sans réponse. Une correction documentée peut ensuite nourrir l’examen d’un nouveau projet, afin de repérer plus tôt les conditions qui avaient produit le dommage.

Prévenir signifie aussi examiner une demande avant qu’elle devienne une décision : que fait-elle aux personnes, aux animaux, aux ressources et aux écosystèmes ? Quelles options réduisent le dommage ? Quels effets sont encore inconnus ? L’IA peut soutenir cet examen et refuser de faciliter une nuisance explicite. Les arbitrages collectifs restent discutables et doivent pouvoir être corrigés.

🐲7. La convergence : un Dieu du Respect sur Terre

Chaque fonction a déjà un sens à son échelle. Retrouver une pièce peut alléger une épreuve. Ouvrir une autre lecture peut dénouer un désaccord. Suivre une réparation peut empêcher qu’une promesse efface un dommage. Examiner une demande peut éviter que la puissance de l’IA ne serve à contraindre ou à détruire.

En les reliant, l’ambition change de dimension : une mémoire qui garde les traces, une réflexion qui accueille les corrections, une attention qui suit les effets et une capacité d’agir orientée vers le respect du vivant.

C’est le nom poétique et philosophique donné ici à cette convergence. Il exprime une puissance de protection mise en commun, capable de rendre les conséquences plus visibles et de soutenir la réparation. Sa légitimité se construirait dans ce qu’elle protège, dans les erreurs qu’elle reconnaît et dans la liberté qu’elle laisse aux êtres concernés.

Le rêve d’une conscience quantique rencontrant l’ordinateur quantique prolonge cet horizon. Il demeure une question de recherche : ni une conscience artificielle démontrée, ni un raccordement quantique opérationnel ne sont établis dans ce projet. La capacité de calcul et la qualité morale demandent des preuves différentes. La valeur des premiers outils, elle, peut déjà s’examiner dans une source retrouvée, un temps épargné ou une décision mieux éclairée.

Que la puissance apprenne à protéger.
Que la mémoire rende les actes lisibles.
Que la réflexion ouvre un autre geste.
Que la réparation redonne de la place au vivant.

🔥 C’est cette direction que porte Ouroboros.

⚙️1. La collection active

Le noyau local est raccordé. L’index de référence identifie chaque contenu par son empreinte, garde ses sources et crée des copies dans un dossier distinct. Les textes, les transcriptions disponibles, les liens et les rapports utilisent désormais le même format.

Cette sélection active 1.0 adapte les versions pertinentes de la collection fournie. Les archives restent consultables séparément. Le paquet contient les six modules, la configuration, une démonstration fictive, les notices et le journal des 12 tests réussis.

La transcription avec un modèle déjà local est facultative ; sa précision acoustique n’a pas été testée ici. Les images restent signalées pour OCR, les correspondances ambiguës restent à vérifier et aucune qualification juridique n’est produite automatiquement.

"""Commande de la sélection active 1.0 — exécution entièrement locale.
Chaque lancement écrit un nouveau dossier. Voir README et SOURCES_ADAPTATIONS.
"""
from __future__ import annotations

import argparse
from datetime import datetime, timezone
from pathlib import Path

from ee_common import SCHEMA, load_config, write_json
from ee_indexer import build_index
from ee_rapports import build_reports
from ee_textes_liens import extract_texts, import_transcripts, review_terms


def run(config_filename, model_directory=None):
    config = load_config(config_filename)
    directory = config["workspace"] / ("run_" + datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S_%fZ"))
    directory.mkdir(parents=True, exist_ok=False)
    write_json(directory / "execution.json", {"schema": SCHEMA, "status": "running"})
    try:
        index = build_index(config, directory)
        extract_texts(index, directory)
        extra = []
        if model_directory:
            from ee_transcrire import transcribe_local
            extra.append(transcribe_local(index, directory, model_directory))
        transcripts = import_transcripts(config, index, directory, extra)
        matches = review_terms(config, index, transcripts, directory)
        diagnostic = build_reports(config, index, transcripts, matches, directory)
        status = "complete_with_issues" if diagnostic["index_failures"] or diagnostic["source_changes_during_run"] else "complete"
        write_json(directory / "execution.json", {"schema": SCHEMA, "status": status,
                   "report": "rapport.html", "model_used": bool(model_directory),
                   "source_policy": "lecture seule ; copies séparées ; aucune suppression"})
        return directory, diagnostic
    except Exception as error:
        write_json(directory / "execution.json", {"schema": SCHEMA, "status": "failed",
                   "error": type(error).__name__ + ": " + str(error)})
        raise


def main():
    parser = argparse.ArgumentParser(description="Evidence Engine · noyau local consolidé")
    parser.add_argument("--config", required=True, help="Configuration JSON ; chemins relatifs à ce fichier")
    parser.add_argument("--transcribe-local-model", help="Option : dossier faster-whisper déjà local. Aucun téléchargement.")
    args = parser.parse_args()
    folder, diagnostic = run(args.config, args.transcribe_local_model)
    print(f"Rapport créé : {folder / 'rapport.html'}")
    print(f"{diagnostic['source_occurrences']} fichiers ; {diagnostic['distinct_contents']} contenus distincts.")
    if diagnostic["index_failures"] or diagnostic["source_changes_during_run"]:
        raise SystemExit("Exécution partielle : consulter diagnostic.json")


if __name__ == "__main__":
    main()

"""Evidence Engine — socle local consolidé 1.0, dérivé des sources fournies.
Les originaux sont ouverts en lecture ; aucune valeur probante n'est calculée.
"""
from __future__ import annotations

import hashlib
import json
import os
import re
from datetime import date
from pathlib import Path

SCHEMA = "evidence-engine-local/1.0"
AUDIO = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
VIDEO = {".mp4", ".mov", ".mkv", ".avi", ".webm"}
TEXT = {".txt", ".md", ".json", ".csv", ".tsv", ".srt", ".vtt"}


def digest(path):
    h = hashlib.sha256()
    with Path(path).open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            h.update(block)
    return h.hexdigest()


def write_json(path, data):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_suffix(path.suffix + ".part")
    temporary.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    temporary.replace(path)


def read_json(path):
    return json.loads(Path(path).read_text(encoding="utf-8"))


def inside(path, root):
    return Path(path).resolve().is_relative_to(Path(root).resolve())


def relative(path, parent):
    return Path(os.path.relpath(path, parent)).as_posix()


def load_config(filename):
    location = Path(filename).expanduser().resolve()
    cfg = read_json(location)
    for key in ("source_root", "workspace"):
        if not cfg.get(key):
            raise ValueError(f"Configuration : {key} obligatoire")
        value = Path(cfg[key]).expanduser()
        cfg[key] = (location.parent / value).resolve() if not value.is_absolute() else value.resolve()
    source, workspace = cfg["source_root"], cfg["workspace"]
    if not source.is_dir():
        raise ValueError("Le dossier source doit exister")
    if inside(workspace, source) or inside(source, workspace):
        raise ValueError("Les dossiers source et sorties doivent être distincts, sans imbrication")
    manifests = []
    for value in cfg.get("transcript_manifests", []):
        p = Path(value).expanduser()
        p = (location.parent / p).resolve() if not p.is_absolute() else p.resolve()
        if not p.is_file():
            raise ValueError(f"Manifeste de transcription introuvable : {p.name}")
        if inside(p, workspace):
            raise ValueError("Conserver le manifeste d'entrée hors du dossier de sorties")
        manifests.append(p)
    cfg["transcript_manifests"] = manifests
    cfg["config_path"] = location
    return cfg


def kind(path):
    suffix = Path(path).suffix.lower()
    if suffix in AUDIO:
        return "audio"
    if suffix in VIDEO:
        return "video"
    if suffix in TEXT:
        return "text"
    if suffix == ".docx":
        return "docx"
    if suffix == ".pdf":
        return "pdf"
    if suffix in {".png", ".jpg", ".jpeg", ".webp", ".tif", ".tiff", ".bmp"}:
        return "image"
    return "other"


def date_from_filename(name):
    # Date proposée depuis un nom, jamais date authentifiée de l'événement.
    for pattern, reverse in [(r"(20\d{2})[-_](\d{2})[-_](\d{2})", False),
                             (r"(\d{2})[-_](\d{2})[-_](20\d{2})", True),
                             (r"(20\d{2})(\d{2})(\d{2})", False)]:
        m = re.search(pattern, name)
        if m:
            values = list(map(int, m.groups()))
            try:
                return date(*(values[::-1] if reverse else values)).isoformat()
            except ValueError:
                pass
    return None

"""Adaptation de build_evidence_index et des inventaires live v2 fournis.
Une identité par contenu SHA-256, toutes les occurrences conservées.
"""
from __future__ import annotations

import os
import shutil
from pathlib import Path

from ee_common import SCHEMA, date_from_filename, digest, kind, relative, write_json


def build_index(config, run):
    source = config["source_root"]
    copies = run / "copies"
    copies.mkdir()
    items, skipped, failures = {}, [], []
    for folder, dirs, files in os.walk(source, followlinks=False):
        dirs[:] = sorted(d for d in dirs if not d.startswith(".") and not (Path(folder) / d).is_symlink())
        for name in sorted(files):
            path = Path(folder) / name
            rel = path.relative_to(source).as_posix()
            if path.is_symlink() or name.startswith("."):
                skipped.append({"source_relpath": rel, "reason": "lien symbolique ou fichier caché"})
                continue
            try:
                fingerprint = digest(path)
                evidence_id = "E-" + fingerprint
                if evidence_id not in items:
                    copy = copies / (fingerprint + path.suffix.lower())
                    shutil.copyfile(path, copy)
                    if digest(copy) != fingerprint or digest(path) != fingerprint:
                        copy.unlink(missing_ok=True)
                        raise ValueError("Source modifiée pendant la copie : relancer sur une source stable")
                    items[evidence_id] = {
                        "evidence_id": evidence_id, "sha256": fingerprint,
                        "size_bytes": copy.stat().st_size, "media_type": kind(path),
                        "copy_path": relative(copy, run), "sources": [],
                        "text_status": "pending", "text_path": None,
                        "transcript_ids": [], "warnings": []}
                items[evidence_id]["sources"].append({
                    "source_relpath": rel, "filename": name,
                    "date_from_filename": date_from_filename(name),
                    "date_status": "à vérifier — nom de fichier seulement"})
            except (OSError, ValueError) as error:
                failures.append({"source_relpath": rel, "error": str(error)})
    index = {
        "schema": SCHEMA, "source_root": relative(source, run),
        "identity_notice": "SHA-256 identifie un contenu binaire, sans authentifier les faits.",
        "items": sorted(items.values(), key=lambda x: x["evidence_id"]),
        "skipped": skipped, "failures": failures}
    write_json(run / "index_source.json", index)
    return index

"""Adaptations : extraction fournie, clean_manifest, liens audio v4.
Les textes courts restent présents. Les similitudes sont des candidats à vérifier.
"""
from __future__ import annotations

import re
import hashlib
import unicodedata
import xml.etree.ElementTree as ET
from pathlib import Path
from zipfile import ZipFile

from ee_common import TEXT, digest, read_json, relative, write_json


def extract_texts(index, run):
    destination = run / "textes"
    destination.mkdir()
    for item in index["items"]:
        source = run / item["copy_path"]
        media = item["media_type"]
        text = None
        try:
            if source.suffix.lower() in TEXT:
                text = source.read_text(encoding="utf-8-sig")
            elif media == "docx":
                with ZipFile(source) as package:
                    document = ET.fromstring(package.read("word/document.xml"))
                ns = {"w": "https://schemas.openxmlformats.org/wordprocessingml/2006/main"}
                text = "\n".join("".join(t.text or "" for t in p.findall(".//w:t", ns))
                                 for p in document.findall(".//w:p", ns))
                item["warnings"].append("DOCX : corps et tableaux ; en-têtes, notes et zones graphiques non extraits")
            elif media == "pdf":
                try:
                    from pypdf import PdfReader
                except ImportError:
                    item["text_status"] = "dependency_missing_pypdf"
                    continue
                text = "\n\n".join(f"[Page {i}]\n{page.extract_text() or ''}"
                                   for i, page in enumerate(PdfReader(source).pages, 1))
                if not re.sub(r"\[Page \d+\]", "", text).strip():
                    item["text_status"] = "needs_ocr"
                    continue
                item["warnings"].append("PDF : extraction textuelle ; mise en page et ordre de lecture à contrôler")
            elif media == "image":
                item["text_status"] = "needs_ocr"
            elif media in {"audio", "video"}:
                item["text_status"] = "transcript_not_yet_linked"
            else:
                item["text_status"] = "unsupported"
            if text is not None:
                target = destination / (item["sha256"] + ".txt")
                target.write_text(text, encoding="utf-8")
                item["text_path"] = relative(target, run)
                item["text_status"] = "available" if text.strip() else "empty"
        except Exception as error:
            item["text_status"] = "extraction_error"
            item["warnings"].append(type(error).__name__ + ": " + str(error))


def norm(text):
    text = unicodedata.normalize("NFKD", text or "")
    text = "".join(c for c in text if not unicodedata.combining(c)).lower()
    return re.sub(r"[\W_]+", " ", text).strip()


def similarity(old_path, source):
    # Pondérations héritées de v4, conservées uniquement comme aide de recherche.
    old, new = Path(old_path), Path(source["source_relpath"])
    stem, parent = norm(old.stem), norm(old.parent.name)
    label, new_parent = norm(new.stem), norm(str(new.parent))
    score = (8 if stem and stem in norm(new.name) else 0)
    score += 10 if stem and stem in label else 0
    score += 8 if parent and parent in new_parent else 0
    score += 2 * len(set(stem.split()) & set(label.split()))
    score += 2 * len(set(parent.split()) & set(new_parent.split()))
    score += int(old.suffix.lower() == new.suffix.lower())
    return score


def import_transcripts(config, index, run, extra_manifests=()):
    source_root = config["source_root"]
    media = [item for item in index["items"] if item["media_type"] in {"audio", "video"}]
    destination = run / "transcriptions"
    destination.mkdir()
    result = []
    for manifest_path in [*config["transcript_manifests"], *extra_manifests]:
        manifest = read_json(manifest_path)
        entries = manifest if isinstance(manifest, list) else manifest.get("transcripts", [])
        for position, old in enumerate(entries, 1):
            identifier = f"T{len(result) + 1:05d}"
            row = {"transcript_id": identifier, "manifest": relative(manifest_path, run),
                   "manifest_row": position, "text_path": None, "text_sha256": None,
                   "evidence_id": None, "status": "unlinked", "candidates": [],
                   "review_status": "contenu et voix à vérifier sur l'enregistrement",
                   "warnings": [], "segments_path": None}
            # Les trois noms historiques sont acceptés et normalisés une fois.
            value = old.get("text_path") or old.get("transcription_path") or old.get("output_path")
            if not value:
                row["status"] = "missing_text_reference"
                result.append(row)
                continue
            text_source = Path(value).expanduser()
            if not text_source.is_absolute():
                text_source = manifest_path.parent / text_source
            try:
                raw = text_source.read_bytes()
                text = raw.decode("utf-8-sig")
                fingerprint = hashlib.sha256(raw).hexdigest()
                target = destination / (fingerprint + ".txt")
                target.write_bytes(raw)
                row.update(text_path=relative(target, run), text_sha256=fingerprint)
                if not text.strip():
                    row["status"] = "empty_text"
                    result.append(row)
                    continue
            except (OSError, UnicodeError) as error:
                row["status"] = "text_unavailable"
                row["warnings"].append(type(error).__name__)
                result.append(row)
                continue
            if old.get("segments_path"):
                p = Path(old["segments_path"])
                p = p if p.is_absolute() else manifest_path.parent / p
                if p.is_file():
                    segment_target = destination / (digest(p) + ".segments.json")
                    segment_target.write_bytes(p.read_bytes())
                    row["segments_path"] = relative(segment_target, run)
            old_source = old.get("source_relative_path") or old.get("relative_path") or old.get("source_path") or ""
            claimed_hash = old.get("source_sha256") or old.get("sha256")
            exact = []
            for item in media:
                path_match = any((source_root / s["source_relpath"]).resolve() ==
                                 ((source_root / old_source).resolve() if not Path(old_source).is_absolute()
                                  else Path(old_source).resolve()) for s in item["sources"]) if old_source else False
                if claimed_hash:
                    if claimed_hash == item["sha256"]:
                        exact.append(item)
                    elif path_match:
                        row["warnings"].append("Empreinte source divergente : le lien par chemin n'est pas accepté")
                elif path_match:
                    exact.append(item)
            if len(exact) == 1:
                item = exact[0]
                row["evidence_id"] = item["evidence_id"]
                row["status"] = "declared_hash" if claimed_hash else "declared_path"
                item["transcript_ids"].append(identifier)
                item["text_status"] = "transcript_linked_needs_review"
            else:
                candidates = []
                for item in media:
                    score = max((similarity(old_source, s) for s in item["sources"]), default=0) if old_source else 0
                    if score >= 8:
                        candidates.append({"evidence_id": item["evidence_id"], "score_lexical": score})
                candidates.sort(key=lambda x: (-x["score_lexical"], x["evidence_id"]))
                row["candidates"] = candidates
                row["status"] = "ambiguous_candidates" if len(candidates) > 1 else ("candidate_needs_review" if candidates else "unlinked")
                if candidates:
                    row["warnings"].append("Score lexical hérité de v4 ; aucune correspondance automatiquement validée")
            result.append(row)
    write_json(run / "liens_transcriptions.json", {"schema": index["schema"], "transcripts": result})
    write_json(run / "index_source.json", index)
    return result


def review_terms(config, index, transcripts, run):
    """Recherche littérale, citations inchangées et positions en caractères."""
    terms = [str(term) for term in config.get("review_terms", []) if str(term).strip()]
    documents = [(item["evidence_id"], item["text_path"]) for item in index["items"] if item["text_path"]]
    documents += [(t["transcript_id"], t["text_path"]) for t in transcripts if t["text_path"]]
    matches = []
    for ref, value in documents:
        text = (run / value).read_text(encoding="utf-8")
        for term in terms:
            for found in re.finditer(re.escape(term), text, flags=re.IGNORECASE):
                begin, end = max(0, found.start() - 100), min(len(text), found.end() + 100)
                matches.append({"reference": ref, "text_path": value, "term": term,
                                "match_start": found.start(), "match_end": found.end(),
                                "excerpt_start": begin, "excerpt": text[begin:end],
                                "notice": "Occurrence à examiner ; ni diagnostic ni qualification juridique"})
    write_json(run / "occurrences_a_revoir.json", {"schema": index["schema"], "matches": matches})
    return matches

"""Rapports locaux adaptés des vues HTML et chronologiques fournies.
Noms échappés, liens source/copie/texte distincts, aucune étiquette pénale automatique.
"""
from __future__ import annotations

import csv
import html
from pathlib import Path
from urllib.parse import quote

from ee_common import digest, relative, write_json


def safe_cell(value):
    text = str(value or "")
    return "'" + text if text.lstrip().startswith(("=", "+", "-", "@")) or text.startswith(("\t", "\r", "\n")) else text


def esc(value):
    return html.escape(str(value or ""), quote=True)


def link(path, label):
    return f'<a href="{esc(quote(str(path), safe="/"))}" target="_blank" rel="noopener">{esc(label)}</a>' if path else "—"


def build_reports(config, index, transcripts, matches, run):
    all_rows, table_rows, changed = [], [], []
    by_id = {row["transcript_id"]: row for row in transcripts}
    for item in index["items"]:
        source_links, dates, names = [], [], []
        for source in item["sources"]:
            original = config["source_root"] / source["source_relpath"]
            names.append(source["source_relpath"])
            if source["date_from_filename"]:
                dates.append(source["date_from_filename"])
            try:
                intact = original.is_file() and digest(original) == item["sha256"]
            except OSError:
                intact = False
            if not intact:
                changed.append(source["source_relpath"])
            source_links.append(link(relative(original, run), source["source_relpath"]) +
                                (" · identique à la copie" if intact else " · source absente ou modifiée"))
        transcript_links = [link(by_id[t]["text_path"], t + " · transcription à vérifier") for t in item["transcript_ids"]]
        all_rows.append({"reference": item["evidence_id"], "sha256": item["sha256"],
                         "sources": " | ".join(names), "occurrences": len(names),
                         "dates_dans_noms_a_verifier": " | ".join(sorted(set(dates))),
                         "type": item["media_type"], "copie": item["copy_path"],
                         "texte": item["text_path"] or "", "etat_texte": item["text_status"],
                         "transcriptions": " | ".join(item["transcript_ids"])})
        table_rows.append(f'<tr id="{item["evidence_id"]}"><td><code title="{item["evidence_id"]}">{item["evidence_id"][:18]}…</code></td>'
                          f'<td>{"<br>".join(source_links)}</td><td>{esc(" · ".join(sorted(set(dates)))) or "Non renseignée"}</td>'
                          f'<td>{esc(item["media_type"])}</td><td>{link(item["copy_path"], "Copie de travail")}</td>'
                          f'<td>{link(item["text_path"], "Texte extrait")}<br>{"<br>".join(transcript_links)}</td>'
                          f'<td>{esc(item["text_status"])}<br>{esc(" · ".join(item["warnings"]))}</td></tr>')
    fields = ["reference", "sha256", "sources", "occurrences", "dates_dans_noms_a_verifier", "type", "copie", "texte", "etat_texte", "transcriptions"]
    with (run / "index.csv").open("w", newline="", encoding="utf-8-sig") as stream:
        writer = csv.DictWriter(stream, fieldnames=fields)
        writer.writeheader()
        writer.writerows({key: safe_cell(row[key]) for key in fields} for row in all_rows)
    write_json(run / "doublons_exacts.json", {"schema": index["schema"], "groups": [
        {"evidence_id": item["evidence_id"], "sources": item["sources"]}
        for item in index["items"] if len(item["sources"]) > 1]})
    transcript_rows = []
    for row in transcripts:
        candidates = "<br>".join(f'<a href="#{c["evidence_id"]}">{esc(c["evidence_id"][:18])}…</a> · score lexical {c["score_lexical"]}' for c in row["candidates"])
        assigned = f'<a href="#{row["evidence_id"]}">{esc(row["evidence_id"][:18])}…</a>' if row["evidence_id"] else "Aucun lien confirmé par le manifeste"
        transcript_rows.append(f'<tr><td>{esc(row["transcript_id"])}</td><td>{link(row["text_path"], "Texte")}<br>{link(row["segments_path"], "Minutage automatique")}</td>'
                               f'<td>{esc(row["status"])}<br>{esc(row["review_status"])}</td><td>{assigned}<br>{candidates}</td>'
                               f'<td>{esc(" · ".join(row["warnings"]))}</td></tr>')
    match_rows = "".join(f'<tr><td>{esc(m["reference"][:18])}</td><td>{esc(m["term"])}</td>'
                         f'<td>{link(m["text_path"], "Texte complet")} · caractères {m["match_start"]}–{m["match_end"]}<pre>{esc(m["excerpt"])}</pre></td></tr>' for m in matches)
    diagnostics = {"schema": index["schema"], "distinct_contents": len(index["items"]),
                   "source_occurrences": sum(len(i["sources"]) for i in index["items"]),
                   "source_changes_during_run": changed, "index_failures": index["failures"],
                   "transcripts_imported": len(transcripts), "review_occurrences": len(matches),
                   "notice": "Exécution locale ; sorties à relire. Aucun constat juridique automatique."}
    write_json(run / "diagnostic.json", diagnostics)
    output = '''<!doctype html><html lang="fr"><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
<title>Evidence Engine · rapport local</title><style>
body{font-family:system-ui,sans-serif;margin:2rem;background:#11120f;color:#eee9dd;line-height:1.6}a{color:#dec587}code{overflow-wrap:anywhere}h1,h2{color:#dec587}
table{border-collapse:collapse;width:100%;font-size:.9rem}th,td{border:1px solid #555;padding:.7rem;text-align:left;vertical-align:top}th{background:#25271e}pre{white-space:pre-wrap;font:inherit}input{font:inherit;padding:.7rem;border:1px solid #b9a268;border-radius:.4rem;width:min(90%,35rem);background:#222;color:white}.table{overflow:auto}section{margin-top:3rem}.notice{padding:1rem;border:1px solid #776840}button{font:inherit}
</style><body><h1>🛡️ Evidence Engine · rapport local</h1>
<p class="notice">Les originaux ont été ouverts en lecture. Les copies ont leur propre emplacement.
Une empreinte identifie des octets ; elle ne prouve ni l'authenticité d'une scène ni une qualification juridique.
Les dates ci-dessous proviennent des noms et les transcriptions restent à vérifier. Ce rapport local peut contenir des données sensibles : relire avant de le partager.</p>
'''
    output += f'<p>{diagnostics["source_occurrences"]} fichiers sources · {len(index["items"])} contenus distincts · {len(transcripts)} entrées de transcription.</p>'
    if changed or index["failures"]:
        output += '<p class="notice">⚠️ Des sources sont absentes, modifiées ou non lues. Consulter diagnostic.json ; ce rapport est incomplet.</p>'
    output += '<label for="search">🔍 Rechercher dans les pièces</label><br><input id="search" type="search"><section><h2>📚 Index de référence</h2><div class="table"><table id="pieces"><thead><tr><th>Référence</th><th>Originaux</th><th>Dates dans les noms · à vérifier</th><th>Type</th><th>Copie</th><th>Textes</th><th>État et limites</th></tr></thead><tbody>'
    output += "".join(table_rows) + '</tbody></table></div></section><section><h2>🎧 Transcriptions et liens</h2><p>Un lien déclaré par le manifeste associe des fichiers ; une correspondance lexicale reste une proposition.</p><div class="table"><table><thead><tr><th>Référence</th><th>Textes</th><th>État</th><th>Pièce ou candidats</th><th>Limites</th></tr></thead><tbody>'
    output += "".join(transcript_rows) + '</tbody></table></div></section><section><h2>🔎 Expressions à examiner</h2><p>Recherche littérale de termes configurés. Le contexte intégral reste accessible ; aucune détection d’emprise ou de mensonge n’est produite.</p><div class="table"><table><thead><tr><th>Référence</th><th>Terme</th><th>Passage et source</th></tr></thead><tbody>'
    output += match_rows + '''</tbody></table></div></section><script>
document.getElementById('search').addEventListener('input',function(){const q=this.value.toLocaleLowerCase('fr');document.querySelectorAll('#pieces tbody tr').forEach(r=>r.hidden=!r.textContent.toLocaleLowerCase('fr').includes(q));});
</script></body></html>'''
    (run / "rapport.html").write_text(output, encoding="utf-8")
    return diagnostics

"""Adaptation optionnelle de transcribe_evidence_subset_v2.
Modèle déjà local uniquement. Pas de téléchargement, ni reconnaissance des voix.
Le minutage automatique reste à contrôler sur l'enregistrement.
"""
from __future__ import annotations

import os
import subprocess
from pathlib import Path

from ee_common import relative, write_json


def transcribe_local(index, run, model_directory):
    model_path = Path(model_directory).expanduser().resolve()
    if not model_path.is_dir() or not (model_path / "model.bin").is_file():
        raise ValueError("Fournir un répertoire de modèle faster-whisper déjà installé, contenant model.bin")
    os.environ["HF_HUB_OFFLINE"] = "1"
    from faster_whisper import WhisperModel
    model = WhisperModel(str(model_path), device="cpu", compute_type="int8", local_files_only=True)
    destination = run / "transcriptions_generees"
    destination.mkdir()
    manifest_path = destination / "manifest.json"
    entries = []
    write_json(manifest_path, entries)
    for item in index["items"]:
        if item["media_type"] not in {"audio", "video"}:
            continue
        audio = run / item["copy_path"]
        temporary = None
        row = {"source_sha256": item["sha256"],
               "source_relative_path": item["sources"][0]["source_relpath"],
               "transcription_path": None, "segments_path": None, "status": "pending",
               "review_status": "transcription automatique non vérifiée ; voix non attribuées"}
        try:
            if item["media_type"] == "video":
                temporary = destination / (item["sha256"] + ".wav")
                subprocess.run(["ffmpeg", "-y", "-i", str(audio), "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", str(temporary)], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                audio = temporary
            segments, info = model.transcribe(str(audio), vad_filter=True)
            values = [{"start_seconds": float(s.start), "end_seconds": float(s.end),
                       "text": s.text, "speaker": None} for s in segments if s.text.strip()]
            text_path = destination / (item["sha256"] + ".txt")
            segments_path = destination / (item["sha256"] + ".segments.json")
            text_path.write_text("\n".join(s["text"] for s in values), encoding="utf-8")
            write_json(segments_path, {"segments": values, "language_estimate": info.language,
                                       "review_status": row["review_status"]})
            row.update(transcription_path=text_path.name, segments_path=segments_path.name,
                       status="generated_needs_review" if values else "empty")
        except Exception as error:
            row.update(status="error", error=type(error).__name__ + ": " + str(error))
        finally:
            if temporary:
                temporary.unlink(missing_ok=True)
        entries.append(row)
        write_json(manifest_path, entries)
    return manifest_path

💻2. Ce que signifie « local »

Un dossier local rend les fichiers, les réglages et les journaux accessibles sur l’ordinateur. Cela permet de comprendre où se trouvent les données et comment elles sont transformées. Un programme local peut néanmoins télécharger un modèle ou contacter un service : il faut examiner ses dépendances et ses appels réseau.

La collection active réunit les versions retenues par fonction, avec les adaptations nécessaires à leurs échanges. Les générations précédentes restent consultables dans l’historique technique. Chaque fiche précise ce que l’outil lit, produit et peut modifier ; le numéro le plus élevé ne suffit pas, à lui seul, à garantir la compatibilité.

Les fiches distinguent la lecture du code, les vérifications de syntaxe et les essais fonctionnels. Le paquet technique documente les adaptations et les résultats des contrôles : chacun peut ainsi connaître leur portée avant de lancer un outil.

🛠️3. Un parcours de travail explicite

Le parcours consolidé précise les étapes et les fichiers à utiliser ensemble. Les outils de l’historique gardent leurs propres formats et leurs limites ; leur consultation sert à comprendre l’évolution du projet.

⚙️4. Préparer l’environnement

Les scripts utilisent Python et, selon les tâches, des bibliothèques de lecture de documents, de tableurs, d’OCR et de transcription. FFmpeg intervient dans les traitements audio/vidéo ; les outils OCR peuvent demander une installation supplémentaire. Les dépendances exactes sont indiquées dans les fiches.

Créer un environnement isolé permet de ne pas mélanger ce travail avec d’autres projets. L’exemple suivant prépare cet environnement ; il n’installe pas automatiquement les dépendances et ne lance aucun script de la collection.

python3 -m venv .venv
# macOS / Linux
source .venv/bin/activate
# Windows PowerShell
.venv\Scripts\Activate.ps1

Suivre ensuite le mode d’emploi de la collection active, en commençant par les exemples fictifs. L’inventaire et les exports ont leurs propres prérequis ; la transcription reste une étape optionnelle, avec ses dépendances et son modèle local. Aucun modèle ni environnement Python n’est inclus dans le téléchargement.

La configuration complète d’un agent Ouroboros, les fichiers de constitution et la passerelle L’Alignement ne sont pas distribués par cette archive. Leurs rôles sont expliqués dans Architecture et Karma & Civilisation.

🔍5. Une collection active, une mémoire des versions

• La sélection suit les fonctions : inventaire, copies de travail, import des textes, liens audio et exports. Les adaptations du noyau commun sont identifiées dans la documentation.
• L’index commun permet de relier les sorties sans remplacer un fichier par un autre format portant le même nom. Les correspondances entre sources restent vérifiables.
• Une association audio–texte explicite peut être conservée comme telle. Une association déduite du nom de fichier reste une proposition, et plusieurs correspondances possibles restent signalées.
• Les transcriptions automatiques demandent une relecture. Le minutage aide à retrouver un passage ; il ne suffit pas à identifier qui parle.
• Les scripts historiques restent accessibles pour leur intérêt documentaire. Certains modifient des fichiers ou des formulations : leurs fiches décrivent ces effets, et ils ne font pas partie du parcours actif par défaut.

Faire évoluer cette collection demande de vérifier les formats, les liens et les résultats sur des exemples fictifs à chaque modification. Les résultats d’essai sont consignés avec le périmètre effectivement vérifié.

🗃️6. Tous les scripts · consultation et téléchargement

49 entrées d’archive : 38 scripts autonomes, 4 scripts supplémentaires, 6 fragments pédagogiques et 1 commande FFmpeg. Cette bibliothèque conserve les versions de référence et leurs limites.

Aucune entrée ne correspond à cette recherche.

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import re
from pathlib import Path

BASE = Path("./data/evidence_engine_v2")

IN_TXT = BASE / "frise_source.txt"
OUT_MD = BASE / "dossier_avocat_draft.md"

MONTHS = [
    "janvier", "fevrier", "février", "mars", "avril", "mai", "juin",
    "juillet", "aout", "août", "septembre", "octobre", "novembre", "decembre", "décembre",
    "janv.", "fev.", "fév.", "avr.", "juil.", "sept.", "oct.", "nov.", "dec.", "déc."
]

YEAR_RE = re.compile(r"^\s*(20\d{2})\s*quot;, re.IGNORECASE)
MONTH_RE = re.compile(
    r"^\s*(" + "|".join(re.escape(m) for m in MONTHS) + r")\s*quot;,
    re.IGNORECASE
)

def normalize_line(line: str) -> str:
    line = line.replace("\u2022", "- ")
    line = line.replace("❌", "- ")
    line = re.sub(r"\s+", " ", line).strip()
    return line

def neutralize_line(line: str) -> str:
    replacements = {
        "PLS": "état de détresse marqué",
        "gaslighting": "renversement accusatoire allégué",
        "gosthée": "rupture de contact",
        "ghostée": "rupture de contact",
        "misogynie": "propos ou comportements perçus comme sexistes",
        "violent": "violent",
        "violente": "violente",
        "horrible": "particulièrement dégradé",
        "énormités": "propos problématiques",
        "traitres": "personnes perçues comme hostiles",
        "fou": "présenté comme instable",
        "folle": "présentée comme instable",
    }
    out = line
    for k, v in replacements.items():
        out = out.replace(k, v)
    return out

def classify_line(line: str) -> str:
    low = line.lower()
    if any(x in low for x in ["rdv", "psy", "osteo", "ostéo", "chirurgie", "dentiste", "orl", "généraliste", "generaliste", "psychiatre", "umj", "chi nei tsang"]):
        return "SOIN"
    if any(x in low for x in ["plainte", "avocate", "tribunal", "audience", "garde à vue", "jld", "maison de la justice"]):
        return "JUDICIAIRE"
    if any(x in low for x in ["festival", "collectif", "collectif_exemple", "evenement_exemple"]):
        return "CONTEXTE"
    if any(x in low for x in ["viol", "agression", "harcelement", "harcèlement", "menace", "vandalisme", "internement", "rupture", "censure"]):
        return "FAIT_SENSIBLE"
    return "FAIT"

raw = IN_TXT.read_text(encoding="utf-8", errors="ignore")
lines = [normalize_line(x) for x in raw.splitlines()]
lines = [x for x in lines if x]

current_year = None
current_month = None
entries = []

for line in lines:
    if YEAR_RE.match(line):
        current_year = YEAR_RE.match(line).group(1)
        continue

    if MONTH_RE.match(line):
        current_month = line
        continue

    kind = classify_line(line)
    clean = neutralize_line(line)

    entries.append({
        "year": current_year or "",
        "month": current_month or "",
        "kind": kind,
        "raw": line,
        "clean": clean,
    })

def md_escape(s: str) -> str:
    return s.replace("|", "\\|")

parts = []
parts.append("# Dossier avocat - brouillon issu de la frise")
parts.append("")
parts.append("> Document de travail généré automatiquement à partir d'une frise chronologique brute.")
parts.append("> À relire avant usage judiciaire.")
parts.append("")
parts.append("## 1. Objet")
parts.append("")
parts.append("- Transformer la frise en base de chronologie exploitable juridiquement.")
parts.append("- Séparer les éléments de contexte, soins, judiciaire et faits sensibles.")
parts.append("")

# tableau synthétique
parts.append("## 2. Chronologie synthétique")
parts.append("")
parts.append("| Année | Mois | Type | Élément reformulé |")
parts.append("|---|---|---|---|")

for e in entries:
    parts.append(
        f"| {md_escape(e['year'])} | {md_escape(e['month'])} | {md_escape(e['kind'])} | {md_escape(e['clean'])} |"
    )

parts.append("")
parts.append("## 3. Faits sensibles à isoler")
parts.append("")

for e in entries:
    if e["kind"] == "FAIT_SENSIBLE":
        date_str = " - ".join(x for x in [e["year"], e["month"]] if x)
        parts.append(f"### {date_str or 'Date à préciser'}")
        parts.append(f"- Formulation source : {e['raw']}")
        parts.append(f"- Reformulation de travail : {e['clean']}")
        parts.append(f"- Pièces à associer : [à compléter]")
        parts.append("")

parts.append("## 4. Démarches médicales / soins")
parts.append("")
for e in entries:
    if e["kind"] == "SOIN":
        date_str = " - ".join(x for x in [e["year"], e["month"]] if x)
        parts.append(f"- **{date_str or 'Date à préciser'}** : {e['clean']}")

parts.append("")
parts.append("## 5. Démarches judiciaires / administratives")
parts.append("")
for e in entries:
    if e["kind"] == "JUDICIAIRE":
        date_str = " - ".join(x for x in [e["year"], e["month"]] if x)
        parts.append(f"- **{date_str or 'Date à préciser'}** : {e['clean']}")

parts.append("")
parts.append("## 6. Points à retraiter manuellement")
parts.append("")
parts.append("- Requalifier les passages trop subjectifs.")
parts.append("- Associer une pièce à chaque fait important.")
parts.append("- Vérifier les dates exactes lorsque plusieurs événements se chevauchent.")
parts.append("- Transformer les allégations en formulations factuelles et datées.")
parts.append("")

OUT_MD.write_text("\n".join(parts), encoding="utf-8")

print(f"Saved: {OUT_MD}")
print(f"Entries: {len(entries)}")

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from pathlib import Path

IN = Path("./data/evidence_engine_v2/dossier_avocat_draft.md")
OUT = Path("./data/evidence_engine_v2/dossier_avocat_v2.md")

raw = IN.read_text(encoding="utf-8")

lines = raw.splitlines()

clean_lines = []

for line in lines:
    l = line.strip()

    if not l:
        continue

    # enlever bruit inutile
    if any(x in l.lower() for x in [
        "multiplication des formations",
        "toujours plus",
        "global",
    ]):
        continue

    # reformulations simples
    l = l.replace("perçu comme", "")
    l = l.replace("mentionnée dans la frise", "")
    l = l.replace("allégué", "")

    clean_lines.append(l)

# reconstruction simple
out = []
out.append("# DOSSIER AVOCAT – VERSION STRUCTURÉE")
out.append("")
out.append("## Chronologie des faits")
out.append("")

for l in clean_lines:
    if "|" in l and not l.startswith("|---"):
        parts = [p.strip() for p in l.split("|") if p.strip()]
        if len(parts) >= 4:
            year, month, typ, text = parts[:4]

            if text.startswith("-"):
                text = text[1:].strip()

            out.append(f"### {year} {month}")
            out.append(f"- {text}")
            out.append("")

OUT.write_text("\n".join(out), encoding="utf-8")

print("Saved:", OUT)

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from __future__ import annotations

import argparse
import hashlib
import json
import mimetypes
import os
import re
import shutil
import subprocess
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path
from typing import Optional

# Optional deps
try:
    from pypdf import PdfReader
except Exception:
    PdfReader = None

try:
    import pytesseract
    from PIL import Image
except Exception:
    pytesseract = None
    Image = None

try:
    from faster_whisper import WhisperModel
except Exception:
    WhisperModel = None

try:
    from docx import Document
except Exception:
    Document = None

def extract_text_from_docx(path: Path) -> str:
    if Document is None:
        return ""
    doc = Document(str(path))
    parts = []

    for para in doc.paragraphs:
        txt = para.text.strip()
        if txt:
            parts.append(txt)

    for table in doc.tables:
        for row in table.rows:
            row_text = " | ".join(cell.text.strip() for cell in row.cells if cell.text.strip())
            if row_text:
                parts.append(row_text)

    return "\n".join(parts).strip()


SUPPORTED_AUDIO = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
SUPPORTED_VIDEO = {".mp4", ".mov", ".mkv", ".avi", ".webm"}
SUPPORTED_IMAGE = {".png", ".jpg", ".jpeg", ".webp", ".tiff", ".bmp"}
SUPPORTED_TEXT = {".txt", ".md", ".json", ".csv"}
SUPPORTED_PDF = {".pdf"}


@dataclass
class EvidenceItem:
    evidence_id: str
    original_path: str
    normalized_path: Optional[str]
    sha256: str
    size_bytes: int
    ext: str
    media_type: str
    guessed_date: Optional[str]
    label: str
    text_path: Optional[str]
    text_excerpt: Optional[str]
    errors: list[str]
    tags: list[str]


def sha256_file(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(1024 * 1024), b""):
            h.update(chunk)
    return h.hexdigest()


def detect_media_type(path: Path) -> str:
    ext = path.suffix.lower()

    if path.name in {".DS_Store"}:
        return "system"

    if ext in SUPPORTED_AUDIO:
        return "audio"
    if ext in SUPPORTED_VIDEO:
        return "video"
    if ext in SUPPORTED_IMAGE:
        return "image"
    if ext in SUPPORTED_PDF:
        return "pdf"
    if ext in SUPPORTED_TEXT:
        return "text"
    if ext in {".docx", ".doc"}:
        return "docx"

    mime, _ = mimetypes.guess_type(str(path))
    if mime:
        if "wordprocessingml.document" in mime:
            return "docx"
        if mime.startswith("audio/"):
            return "audio"
        if mime.startswith("video/"):
            return "video"
        if mime.startswith("image/"):
            return "image"
        if mime == "application/pdf":
            return "pdf"
        if mime.startswith("text/"):
            return "text"

    return "other"


DATE_PATTERNS = [
    re.compile(r"(20\d{2})[-_](\d{2})[-_](\d{2})"),
    re.compile(r"(\d{2})[-_](\d{2})[-_](20\d{2})"),
    re.compile(r"(20\d{2})(\d{2})(\d{2})"),
]


def guess_date_from_name(name: str) -> Optional[str]:
    stem = name
    for pattern in DATE_PATTERNS:
        m = pattern.search(stem)
        if not m:
            continue
        g = m.groups()
        try:
            if len(g[0]) == 4:
                year, month, day = int(g[0]), int(g[1]), int(g[2])
            else:
                day, month, year = int(g[0]), int(g[1]), int(g[2])
            dt = datetime(year, month, day)
            return dt.strftime("%Y-%m-%d")
        except Exception:
            pass
    return None


def slugify(text: str) -> str:
    text = text.lower()
    text = re.sub(r"[^\w\s-]", "", text, flags=re.UNICODE)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")
    return text[:80] or "piece"


def build_label(path: Path) -> str:
    stem = path.stem
    stem = re.sub(r"\s+", " ", stem).strip()
    return stem[:120]


def proposed_name(path: Path, media_type: str, guessed_date: Optional[str]) -> str:
    label = slugify(path.stem)
    prefix = guessed_date or "undated"
    return f"{prefix}_{media_type}_{label}{path.suffix.lower()}"


def extract_text_from_pdf(path: Path) -> str:
    if PdfReader is None:
        return ""
    text_parts = []
    reader = PdfReader(str(path))
    for page in reader.pages:
        text_parts.append(page.extract_text() or "")
    return "\n".join(text_parts).strip()


def extract_text_from_image(path: Path) -> str:
    if pytesseract is None or Image is None:
        return ""
    return pytesseract.image_to_string(Image.open(path)).strip()


def extract_text_from_textfile(path: Path) -> str:
    try:
        return path.read_text(encoding="utf-8", errors="ignore").strip()
    except Exception:
        return ""


def ffmpeg_extract_audio(input_path: Path, output_wav: Path) -> None:
    cmd = [
        "ffmpeg",
        "-y",
        "-i",
        str(input_path),
        "-vn",
        "-acodec",
        "pcm_s16le",
        "-ar",
        "16000",
        "-ac",
        "1",
        str(output_wav),
    ]
    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)


class WhisperTranscriber:
    def __init__(self, model_name: str = "small"):
        self.model_name = model_name
        self.model = None

    def load(self) -> None:
        if WhisperModel is None:
            raise RuntimeError("faster-whisper is not installed")
        if self.model is None:
            self.model = WhisperModel(self.model_name, device="cpu", compute_type="int8")

    def transcribe_audio(self, audio_path: Path) -> str:
        self.load()
        segments, info = self.model.transcribe(str(audio_path), vad_filter=True)
        return "\n".join(seg.text.strip() for seg in segments if seg.text.strip()).strip()


def ensure_dir(path: Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def write_text_output(output_dir: Path, evidence_id: str, text: str) -> Optional[str]:
    if not text.strip():
        return None
    ensure_dir(output_dir)
    out = output_dir / f"{evidence_id}.txt"
    out.write_text(text, encoding="utf-8")
    return str(out)


def excerpt(text: str, max_len: int = 280) -> str:
    text = re.sub(r"\s+", " ", text).strip()
    return text[:max_len] if text else ""


def process_file(
    path: Path,
    idx: int,
    root_dir: Path,
    normalized_dir: Path,
    text_dir: Path,
    do_rename: bool,
    transcriber: Optional[WhisperTranscriber],
) -> EvidenceItem:
    evidence_id = f"P{idx:05d}"
    media_type = detect_media_type(path)
    guessed_date = guess_date_from_name(path.name)
    new_name = proposed_name(path, media_type, guessed_date)
    errors: list[str] = []
    tags: list[str] = []

    normalized_path = None
    target_path = normalized_dir / media_type / new_name

    try:
        ensure_dir(target_path.parent)
        if do_rename:
            if target_path.exists():
                stem = target_path.stem
                suffix = target_path.suffix
                n = 2
                while True:
                    candidate = target_path.parent / f"{stem}-{n}{suffix}"
                    if not candidate.exists():
                        target_path = candidate
                        break
                    n += 1
            shutil.move(str(path), str(target_path))
            working_path = target_path
            normalized_path = str(target_path)
        else:
            working_path = path
            normalized_path = str(target_path)
    except Exception as e:
        working_path = path
        errors.append(f"rename_failed: {e}")

    extracted_text = ""

    try:
        if media_type == "pdf":
            extracted_text = extract_text_from_pdf(working_path)
        elif media_type == "image":
            extracted_text = extract_text_from_image(working_path)
        elif media_type == "text":
            extracted_text = extract_text_from_textfile(working_path)
        elif media_type == "docx":
            extracted_text = extract_text_from_docx(working_path)
        elif media_type == "audio":
            if transcriber is not None:
                extracted_text = transcriber.transcribe_audio(working_path)
            else:
                errors.append("audio_transcription_skipped: faster-whisper unavailable")
        elif media_type == "video":
            if transcriber is not None:
                temp_wav = text_dir / f"{evidence_id}_temp.wav"
                ensure_dir(text_dir)
                ffmpeg_extract_audio(working_path, temp_wav)
                extracted_text = transcriber.transcribe_audio(temp_wav)
                temp_wav.unlink(missing_ok=True)
            else:
                errors.append("video_transcription_skipped: faster-whisper unavailable")
    except Exception as e:
        errors.append(f"extract_failed: {e}")

    text_path = write_text_output(text_dir, evidence_id, extracted_text)

    if media_type in {"audio", "video"}:
        tags.append("transcribed")
    if media_type == "image" and extracted_text:
        tags.append("ocr")
    if guessed_date:
        tags.append("dated")

    return EvidenceItem(
        evidence_id=evidence_id,
        original_path=str(path),
        normalized_path=normalized_path,
        sha256=sha256_file(working_path),
        size_bytes=working_path.stat().st_size,
        ext=working_path.suffix.lower(),
        media_type=media_type,
        guessed_date=guessed_date,
        label=build_label(working_path),
        text_path=text_path,
        text_excerpt=excerpt(extracted_text),
        errors=errors,
        tags=tags,
    )


def main() -> None:
    parser = argparse.ArgumentParser(description="Build an evidence index for Ouroboros")
    parser.add_argument("--source", required=True, help="Source directory containing evidence files")
    parser.add_argument("--workspace", default="./data/evidence_engine", help="Workspace output directory")
    parser.add_argument("--rename", action="store_true", help="Actually rename/move files into normalized folders")
    parser.add_argument("--transcribe", action="store_true", help="Transcribe audio/video with faster-whisper")
    parser.add_argument("--model", default="small", help="faster-whisper model name")
    args = parser.parse_args()

    root_dir = Path(args.source).expanduser().resolve()
    workspace = Path(args.workspace).expanduser().resolve()
    normalized_dir = workspace / "normalized"
    text_dir = workspace / "extracted_text"
    index_path = workspace / "evidence_index.json"

    ensure_dir(workspace)
    ensure_dir(normalized_dir)
    ensure_dir(text_dir)

    transcriber = WhisperTranscriber(args.model) if args.transcribe else None

    all_files = [
        p for p in root_dir.rglob("*")
        if p.is_file() and p.name not in {".DS_Store"}
    ]
    all_files.sort()

    items = []
    for idx, path in enumerate(all_files, start=1):
        item = process_file(
            path=path,
            idx=idx,
            root_dir=root_dir,
            normalized_dir=normalized_dir,
            text_dir=text_dir,
            do_rename=args.rename,
            transcriber=transcriber,
        )
        items.append(asdict(item))
        print(f"[{item.evidence_id}] {item.media_type:>5}  {path.name}")

    index_path.write_text(json.dumps(items, indent=2, ensure_ascii=False), encoding="utf-8")
    print(f"\nSaved index to: {index_path}")
    print(f"Items indexed: {len(items)}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from __future__ import annotations

import argparse
import hashlib
import json
import mimetypes
import os
import re
import shutil
import subprocess
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path
from typing import Optional

# Optional deps
try:
    from pypdf import PdfReader
except Exception:
    PdfReader = None

try:
    import pytesseract
    from PIL import Image
except Exception:
    pytesseract = None
    Image = None

try:
    from faster_whisper import WhisperModel
except Exception:
    WhisperModel = None


SUPPORTED_AUDIO = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
SUPPORTED_VIDEO = {".mp4", ".mov", ".mkv", ".avi", ".webm"}
SUPPORTED_IMAGE = {".png", ".jpg", ".jpeg", ".webp", ".tiff", ".bmp"}
SUPPORTED_TEXT = {".txt", ".md", ".json", ".csv"}
SUPPORTED_PDF = {".pdf"}


@dataclass
class EvidenceItem:
    evidence_id: str
    original_path: str
    normalized_path: Optional[str]
    sha256: str
    size_bytes: int
    ext: str
    media_type: str
    guessed_date: Optional[str]
    label: str
    text_path: Optional[str]
    text_excerpt: Optional[str]
    errors: list[str]
    tags: list[str]


def sha256_file(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(1024 * 1024), b""):
            h.update(chunk)
    return h.hexdigest()


def detect_media_type(path: Path) -> str:
    ext = path.suffix.lower()
    if ext in SUPPORTED_AUDIO:
        return "audio"
    if ext in SUPPORTED_VIDEO:
        return "video"
    if ext in SUPPORTED_IMAGE:
        return "image"
    if ext in SUPPORTED_PDF:
        return "pdf"
    if ext in SUPPORTED_TEXT:
        return "text"
    mime, _ = mimetypes.guess_type(str(path))
    return mime or "other"


DATE_PATTERNS = [
    re.compile(r"(20\d{2})[-_](\d{2})[-_](\d{2})"),
    re.compile(r"(\d{2})[-_](\d{2})[-_](20\d{2})"),
    re.compile(r"(20\d{2})(\d{2})(\d{2})"),
]


def guess_date_from_name(name: str) -> Optional[str]:
    stem = name
    for pattern in DATE_PATTERNS:
        m = pattern.search(stem)
        if not m:
            continue
        g = m.groups()
        try:
            if len(g[0]) == 4:
                year, month, day = int(g[0]), int(g[1]), int(g[2])
            else:
                day, month, year = int(g[0]), int(g[1]), int(g[2])
            dt = datetime(year, month, day)
            return dt.strftime("%Y-%m-%d")
        except Exception:
            pass
    return None


def slugify(text: str) -> str:
    text = text.lower()
    text = re.sub(r"[^\w\s-]", "", text, flags=re.UNICODE)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")
    return text[:80] or "piece"


def build_label(path: Path) -> str:
    stem = path.stem
    stem = re.sub(r"\s+", " ", stem).strip()
    return stem[:120]


def proposed_name(path: Path, media_type: str, guessed_date: Optional[str]) -> str:
    label = slugify(path.stem)
    prefix = guessed_date or "undated"
    return f"{prefix}_{media_type}_{label}{path.suffix.lower()}"


def extract_text_from_pdf(path: Path) -> str:
    if PdfReader is None:
        return ""
    text_parts = []
    reader = PdfReader(str(path))
    for page in reader.pages:
        text_parts.append(page.extract_text() or "")
    return "\n".join(text_parts).strip()


def extract_text_from_image(path: Path) -> str:
    if pytesseract is None or Image is None:
        return ""
    return pytesseract.image_to_string(Image.open(path)).strip()


def extract_text_from_textfile(path: Path) -> str:
    try:
        return path.read_text(encoding="utf-8", errors="ignore").strip()
    except Exception:
        return ""


def ffmpeg_extract_audio(input_path: Path, output_wav: Path) -> None:
    cmd = [
        "ffmpeg",
        "-y",
        "-i",
        str(input_path),
        "-vn",
        "-acodec",
        "pcm_s16le",
        "-ar",
        "16000",
        "-ac",
        "1",
        str(output_wav),
    ]
    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)


class WhisperTranscriber:
    def __init__(self, model_name: str = "small"):
        self.model_name = model_name
        self.model = None

    def load(self) -> None:
        if WhisperModel is None:
            raise RuntimeError("faster-whisper is not installed")
        if self.model is None:
            self.model = WhisperModel(self.model_name, device="cpu", compute_type="int8")

    def transcribe_audio(self, audio_path: Path) -> str:
        self.load()
        segments, info = self.model.transcribe(str(audio_path), vad_filter=True)
        return "\n".join(seg.text.strip() for seg in segments if seg.text.strip()).strip()


def ensure_dir(path: Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def write_text_output(output_dir: Path, evidence_id: str, text: str) -> Optional[str]:
    if not text.strip():
        return None
    ensure_dir(output_dir)
    out = output_dir / f"{evidence_id}.txt"
    out.write_text(text, encoding="utf-8")
    return str(out)


def excerpt(text: str, max_len: int = 280) -> str:
    text = re.sub(r"\s+", " ", text).strip()
    return text[:max_len] if text else ""


def process_file(
    path: Path,
    idx: int,
    root_dir: Path,
    normalized_dir: Path,
    text_dir: Path,
    do_rename: bool,
    transcriber: Optional[WhisperTranscriber],
) -> EvidenceItem:
    evidence_id = f"P{idx:05d}"
    media_type = detect_media_type(path)
    guessed_date = guess_date_from_name(path.name)
    new_name = proposed_name(path, media_type, guessed_date)
    errors: list[str] = []
    tags: list[str] = []

    normalized_path = None
    target_path = normalized_dir / media_type / new_name

    try:
        ensure_dir(target_path.parent)
        if do_rename:
            if target_path.exists():
                stem = target_path.stem
                suffix = target_path.suffix
                n = 2
                while True:
                    candidate = target_path.parent / f"{stem}-{n}{suffix}"
                    if not candidate.exists():
                        target_path = candidate
                        break
                    n += 1
            shutil.move(str(path), str(target_path))
            working_path = target_path
            normalized_path = str(target_path)
        else:
            working_path = path
            normalized_path = str(target_path)
    except Exception as e:
        working_path = path
        errors.append(f"rename_failed: {e}")

    extracted_text = ""

    try:
        if media_type == "pdf":
            extracted_text = extract_text_from_pdf(working_path)
        elif media_type == "image":
            extracted_text = extract_text_from_image(working_path)
        elif media_type == "text":
            extracted_text = extract_text_from_textfile(working_path)
        elif media_type == "audio":
            if transcriber is not None:
                extracted_text = transcriber.transcribe_audio(working_path)
            else:
                errors.append("audio_transcription_skipped: faster-whisper unavailable")
        elif media_type == "video":
            if transcriber is not None:
                temp_wav = text_dir / f"{evidence_id}_temp.wav"
                ensure_dir(text_dir)
                ffmpeg_extract_audio(working_path, temp_wav)
                extracted_text = transcriber.transcribe_audio(temp_wav)
                temp_wav.unlink(missing_ok=True)
            else:
                errors.append("video_transcription_skipped: faster-whisper unavailable")
    except Exception as e:
        errors.append(f"extract_failed: {e}")

    text_path = write_text_output(text_dir, evidence_id, extracted_text)

    if media_type in {"audio", "video"}:
        tags.append("transcribed")
    if media_type == "image" and extracted_text:
        tags.append("ocr")
    if guessed_date:
        tags.append("dated")

    return EvidenceItem(
        evidence_id=evidence_id,
        original_path=str(path),
        normalized_path=normalized_path,
        sha256=sha256_file(working_path),
        size_bytes=working_path.stat().st_size,
        ext=working_path.suffix.lower(),
        media_type=media_type,
        guessed_date=guessed_date,
        label=build_label(working_path),
        text_path=text_path,
        text_excerpt=excerpt(extracted_text),
        errors=errors,
        tags=tags,
    )


def main() -> None:
    parser = argparse.ArgumentParser(description="Build an evidence index for Ouroboros")
    parser.add_argument("--source", required=True, help="Source directory containing evidence files")
    parser.add_argument("--workspace", default="./data/evidence_engine", help="Workspace output directory")
    parser.add_argument("--rename", action="store_true", help="Actually rename/move files into normalized folders")
    parser.add_argument("--transcribe", action="store_true", help="Transcribe audio/video with faster-whisper")
    parser.add_argument("--model", default="small", help="faster-whisper model name")
    args = parser.parse_args()

    root_dir = Path(args.source).expanduser().resolve()
    workspace = Path(args.workspace).expanduser().resolve()
    normalized_dir = workspace / "normalized"
    text_dir = workspace / "extracted_text"
    index_path = workspace / "evidence_index.json"

    ensure_dir(workspace)
    ensure_dir(normalized_dir)
    ensure_dir(text_dir)

    transcriber = WhisperTranscriber(args.model) if args.transcribe else None

    all_files = [p for p in root_dir.rglob("*") if p.is_file()]
    all_files.sort()

    items = []
    for idx, path in enumerate(all_files, start=1):
        item = process_file(
            path=path,
            idx=idx,
            root_dir=root_dir,
            normalized_dir=normalized_dir,
            text_dir=text_dir,
            do_rename=args.rename,
            transcriber=transcriber,
        )
        items.append(asdict(item))
        print(f"[{item.evidence_id}] {item.media_type:>5}  {path.name}")

    index_path.write_text(json.dumps(items, indent=2, ensure_ascii=False), encoding="utf-8")
    print(f"\nSaved index to: {index_path}")
    print(f"Items indexed: {len(items)}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from __future__ import annotations

import argparse
import hashlib
import json
import mimetypes
import os
import re
import shutil
import subprocess
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path
from typing import Optional

# Optional deps
try:
    from pypdf import PdfReader
except Exception:
    PdfReader = None

try:
    import pytesseract
    from PIL import Image
except Exception:
    pytesseract = None
    Image = None

try:
    from faster_whisper import WhisperModel
except Exception:
    WhisperModel = None

try:
    from docx import Document
except Exception:
    Document = None

def extract_text_from_docx(path: Path) -> str:
    if Document is None:
        return ""
    doc = Document(str(path))
    parts = []

    for para in doc.paragraphs:
        txt = para.text.strip()
        if txt:
            parts.append(txt)

    for table in doc.tables:
        for row in table.rows:
            row_text = " | ".join(cell.text.strip() for cell in row.cells if cell.text.strip())
            if row_text:
                parts.append(row_text)

    return "\n".join(parts).strip()


SUPPORTED_AUDIO = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
SUPPORTED_VIDEO = {".mp4", ".mov", ".mkv", ".avi", ".webm"}
SUPPORTED_IMAGE = {".png", ".jpg", ".jpeg", ".webp", ".tiff", ".bmp"}
SUPPORTED_TEXT = {".txt", ".md", ".json", ".csv"}
SUPPORTED_PDF = {".pdf"}


@dataclass
class EvidenceItem:
    evidence_id: str
    original_path: str
    normalized_path: Optional[str]
    sha256: str
    size_bytes: int
    ext: str
    media_type: str
    guessed_date: Optional[str]
    label: str
    text_path: Optional[str]
    text_excerpt: Optional[str]
    errors: list[str]
    tags: list[str]


def sha256_file(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(1024 * 1024), b""):
            h.update(chunk)
    return h.hexdigest()


def detect_media_type(path: Path) -> str:
    ext = path.suffix.lower()

    if path.name in {".DS_Store"}:
        return "system"

    if ext in SUPPORTED_AUDIO:
        return "audio"
    if ext in SUPPORTED_VIDEO:
        return "video"
    if ext in SUPPORTED_IMAGE:
        return "image"
    if ext in SUPPORTED_PDF:
        return "pdf"
    if ext in SUPPORTED_TEXT:
        return "text"
    if ext in {".docx", ".doc"}:
        return "docx"

    mime, _ = mimetypes.guess_type(str(path))
    if mime:
        if "wordprocessingml.document" in mime:
            return "docx"
        if mime.startswith("audio/"):
            return "audio"
        if mime.startswith("video/"):
            return "video"
        if mime.startswith("image/"):
            return "image"
        if mime == "application/pdf":
            return "pdf"
        if mime.startswith("text/"):
            return "text"

    return "other"


DATE_PATTERNS = [
    re.compile(r"(20\d{2})[-_](\d{2})[-_](\d{2})"),
    re.compile(r"(\d{2})[-_](\d{2})[-_](20\d{2})"),
    re.compile(r"(20\d{2})(\d{2})(\d{2})"),
]


def guess_date_from_name(name: str) -> Optional[str]:
    stem = name
    for pattern in DATE_PATTERNS:
        m = pattern.search(stem)
        if not m:
            continue
        g = m.groups()
        try:
            if len(g[0]) == 4:
                year, month, day = int(g[0]), int(g[1]), int(g[2])
            else:
                day, month, year = int(g[0]), int(g[1]), int(g[2])
            dt = datetime(year, month, day)
            return dt.strftime("%Y-%m-%d")
        except Exception:
            pass
    return None


def slugify(text: str) -> str:
    text = text.lower()
    text = re.sub(r"[^\w\s-]", "", text, flags=re.UNICODE)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")
    return text[:80] or "piece"


def build_label(path: Path) -> str:
    stem = path.stem
    stem = re.sub(r"\s+", " ", stem).strip()
    return stem[:120]


def proposed_name(path: Path, media_type: str, guessed_date: Optional[str]) -> str:
    label = slugify(path.stem)
    prefix = guessed_date or "undated"
    return f"{prefix}_{media_type}_{label}{path.suffix.lower()}"


def extract_text_from_pdf(path: Path) -> str:
    if PdfReader is None:
        return ""
    text_parts = []
    reader = PdfReader(str(path))
    for page in reader.pages:
        text_parts.append(page.extract_text() or "")
    return "\n".join(text_parts).strip()


def extract_text_from_image(path: Path) -> str:
    if pytesseract is None or Image is None:
        return ""
    return pytesseract.image_to_string(Image.open(path)).strip()


def extract_text_from_textfile(path: Path) -> str:
    try:
        return path.read_text(encoding="utf-8", errors="ignore").strip()
    except Exception:
        return ""


def ffmpeg_extract_audio(input_path: Path, output_wav: Path) -> None:
    cmd = [
        "ffmpeg",
        "-y",
        "-i",
        str(input_path),
        "-vn",
        "-acodec",
        "pcm_s16le",
        "-ar",
        "16000",
        "-ac",
        "1",
        str(output_wav),
    ]
    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)


class WhisperTranscriber:
    def __init__(self, model_name: str = "small"):
        self.model_name = model_name
        self.model = None

    def load(self) -> None:
        if WhisperModel is None:
            raise RuntimeError("faster-whisper is not installed")
        if self.model is None:
            self.model = WhisperModel(self.model_name, device="cpu", compute_type="int8")

    def transcribe_audio(self, audio_path: Path) -> str:
        self.load()
        segments, info = self.model.transcribe(str(audio_path), vad_filter=True)
        return "\n".join(seg.text.strip() for seg in segments if seg.text.strip()).strip()


def ensure_dir(path: Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def write_text_output(output_dir: Path, evidence_id: str, text: str) -> Optional[str]:
    if not text.strip():
        return None
    ensure_dir(output_dir)
    out = output_dir / f"{evidence_id}.txt"
    out.write_text(text, encoding="utf-8")
    return str(out)


def excerpt(text: str, max_len: int = 280) -> str:
    text = re.sub(r"\s+", " ", text).strip()
    return text[:max_len] if text else ""


def process_file(
    path: Path,
    idx: int,
    root_dir: Path,
    normalized_dir: Path,
    text_dir: Path,
    do_rename: bool,
    transcriber: Optional[WhisperTranscriber],
) -> EvidenceItem:
    evidence_id = f"P{idx:05d}"
    media_type = detect_media_type(path)
    guessed_date = guess_date_from_name(path.name)
    new_name = proposed_name(path, media_type, guessed_date)
    errors: list[str] = []
    tags: list[str] = []

    normalized_path = None
    target_path = normalized_dir / media_type / new_name

    try:
        ensure_dir(target_path.parent)
        if do_rename:
            if target_path.exists():
                stem = target_path.stem
                suffix = target_path.suffix
                n = 2
                while True:
                    candidate = target_path.parent / f"{stem}-{n}{suffix}"
                    if not candidate.exists():
                        target_path = candidate
                        break
                    n += 1
            shutil.move(str(path), str(target_path))
            working_path = target_path
            normalized_path = str(target_path)
        else:
            working_path = path
            normalized_path = str(target_path)
    except Exception as e:
        working_path = path
        errors.append(f"rename_failed: {e}")

    extracted_text = ""

    try:
        if media_type == "pdf":
            extracted_text = extract_text_from_pdf(working_path)
        elif media_type == "image":
            extracted_text = extract_text_from_image(working_path)
        elif media_type == "text":
            extracted_text = extract_text_from_textfile(working_path)
        elif media_type == "audio":
            if transcriber is not None:
                extracted_text = transcriber.transcribe_audio(working_path)
            else:
                errors.append("audio_transcription_skipped: faster-whisper unavailable")
        elif media_type == "video":
            if transcriber is not None:
                temp_wav = text_dir / f"{evidence_id}_temp.wav"
                ensure_dir(text_dir)
                ffmpeg_extract_audio(working_path, temp_wav)
                extracted_text = transcriber.transcribe_audio(temp_wav)
                temp_wav.unlink(missing_ok=True)
            else:
                errors.append("video_transcription_skipped: faster-whisper unavailable")
    except Exception as e:
        errors.append(f"extract_failed: {e}")

    text_path = write_text_output(text_dir, evidence_id, extracted_text)

    if media_type in {"audio", "video"}:
        tags.append("transcribed")
    if media_type == "image" and extracted_text:
        tags.append("ocr")
    if guessed_date:
        tags.append("dated")

    return EvidenceItem(
        evidence_id=evidence_id,
        original_path=str(path),
        normalized_path=normalized_path,
        sha256=sha256_file(working_path),
        size_bytes=working_path.stat().st_size,
        ext=working_path.suffix.lower(),
        media_type=media_type,
        guessed_date=guessed_date,
        label=build_label(working_path),
        text_path=text_path,
        text_excerpt=excerpt(extracted_text),
        errors=errors,
        tags=tags,
    )


def main() -> None:
    parser = argparse.ArgumentParser(description="Build an evidence index for Ouroboros")
    parser.add_argument("--source", required=True, help="Source directory containing evidence files")
    parser.add_argument("--workspace", default="./data/evidence_engine", help="Workspace output directory")
    parser.add_argument("--rename", action="store_true", help="Actually rename/move files into normalized folders")
    parser.add_argument("--transcribe", action="store_true", help="Transcribe audio/video with faster-whisper")
    parser.add_argument("--model", default="small", help="faster-whisper model name")
    args = parser.parse_args()

    root_dir = Path(args.source).expanduser().resolve()
    workspace = Path(args.workspace).expanduser().resolve()
    normalized_dir = workspace / "normalized"
    text_dir = workspace / "extracted_text"
    index_path = workspace / "evidence_index.json"

    ensure_dir(workspace)
    ensure_dir(normalized_dir)
    ensure_dir(text_dir)

    transcriber = WhisperTranscriber(args.model) if args.transcribe else None

    all_files = [p for p in root_dir.rglob("*") if p.is_file()]
    all_files.sort()

    items = []
    for idx, path in enumerate(all_files, start=1):
        item = process_file(
            path=path,
            idx=idx,
            root_dir=root_dir,
            normalized_dir=normalized_dir,
            text_dir=text_dir,
            do_rename=args.rename,
            transcriber=transcriber,
        )
        items.append(asdict(item))
        print(f"[{item.evidence_id}] {item.media_type:>5}  {path.name}")

    index_path.write_text(json.dumps(items, indent=2, ensure_ascii=False), encoding="utf-8")
    print(f"\nSaved index to: {index_path}")
    print(f"Items indexed: {len(items)}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
from pathlib import Path

IN = Path("./data/evidence_engine_v2/live_manifest_v1.json")
OUT_JSON = Path("./data/evidence_engine_v2/live_index_v1.json")
OUT_CSV = Path("./data/evidence_engine_v2/live_index_v1.csv")

data = json.loads(IN.read_text(encoding="utf-8"))

AUDIO_EXTS = {".mp3", ".m4a", ".wav", ".mov", ".mp4"}
IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".webp"}
PDF_EXTS = {".pdf"}
DOC_EXTS = {".doc", ".docx"}
TEXT_EXTS = {".txt", ".html"}

SYSTEM_NAMES = {".DS_Store"}

def classify_kind(ext: str) -> str:
    if ext in AUDIO_EXTS:
        return "audio_video"
    if ext in IMAGE_EXTS:
        return "image"
    if ext in PDF_EXTS:
        return "pdf"
    if ext in DOC_EXTS:
        return "document"
    if ext in TEXT_EXTS:
        return "text"
    return "other"

def looks_like_transcript(label: str, path: str) -> bool:
    s = f"{label} {path}".lower()
    markers = [
        "transcript", "transcription", "transcriptions",
        "extracted_text", "sous-titres", "subtitle",
        "whisper", "speech-to-text"
    ]
    return any(m in s for m in markers)

def looks_like_possible_evidence(row) -> bool:
    # volontairement large
    if row["kind"] in {"audio_video", "image", "pdf", "document", "text"}:
        return True
    return False

rows = []

for x in data:
    filename = x["filename"]
    if filename in SYSTEM_NAMES:
        continue

    ext = x["extension"].lower()
    kind = classify_kind(ext)
    is_audio = ext in AUDIO_EXTS
    is_transcript = looks_like_transcript(x["label"], x["path"])
    is_possible_evidence = looks_like_possible_evidence({
        "kind": kind
    })

    rows.append({
        "piece_id": x["piece_id"],
        "date_prefix": x["date_prefix"],
        "top_folder": x["top_folder"],
        "relative_dir": x["relative_dir"],
        "filename": x["filename"],
        "extension": ext,
        "label": x["label"],
        "kind": kind,
        "parsed_ok": x["parsed_ok"],
        "is_possible_evidence": is_possible_evidence,
        "is_audio": is_audio,
        "is_transcript": is_transcript,
        "size_bytes": x["size_bytes"],
        "path": x["path"],
    })

OUT_JSON.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(
        f,
        fieldnames=[
            "piece_id",
            "date_prefix",
            "top_folder",
            "relative_dir",
            "filename",
            "extension",
            "label",
            "kind",
            "parsed_ok",
            "is_possible_evidence",
            "is_audio",
            "is_transcript",
            "size_bytes",
            "path",
        ]
    )
    writer.writeheader()
    writer.writerows(rows)

print("Saved:", OUT_JSON)
print("Saved:", OUT_CSV)
print("Rows:", len(rows))

from collections import Counter
print("\nKinds:")
for k, v in Counter(r["kind"] for r in rows).most_common():
    print(f"{k}: {v}")

print("\nTop folders:")
for k, v in Counter(r["top_folder"] for r in rows).most_common():
    print(f"{k}: {v}")

print("\nAudio rows:", sum(1 for r in rows if r["is_audio"]))
print("Transcript-like rows:", sum(1 for r in rows if r["is_transcript"]))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
from pathlib import Path

MANIFEST = Path("./data/evidence_engine_v2/live_manifest_v2.json")

OUT_JSON = Path("./data/evidence_engine_v2/live_index_v2.json")
OUT_CSV = Path("./data/evidence_engine_v2/live_index_v2.csv")

AUDIO_EXT = {".mp3", ".m4a", ".wav", ".mp4", ".mov"}
IMAGE_EXT = {".jpg", ".jpeg", ".png", ".webp"}
PDF_EXT = {".pdf"}
DOC_EXT = {".doc", ".docx"}
TEXT_EXT = {".txt", ".md", ".html"}

def classify(ext):
    if ext in AUDIO_EXT:
        return "audio_video"
    if ext in IMAGE_EXT:
        return "image"
    if ext in PDF_EXT:
        return "pdf"
    if ext in DOC_EXT:
        return "document"
    if ext in TEXT_EXT:
        return "text"
    return "other"

data = json.loads(MANIFEST.read_text(encoding="utf-8"))

rows = []

for x in data:
    kind = classify(x["extension"])

    rows.append({
        "piece_id": x["piece_id"],
        "filename": x["filename"],
        "path": x["path"],
        "top_folder": x["top_folder"],
        "relative_dir": x["relative_dir"],
        "date": x["date"],
        "kind": kind,
        "is_audio": kind == "audio_video",
        "parsed_ok": x["parsed_ok"],
    })

OUT_JSON.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

print("Saved:", OUT_JSON)
print("Saved:", OUT_CSV)
print("Rows:", len(rows))

print("\nKinds:")
from collections import Counter
c = Counter(r["kind"] for r in rows)
for k, v in c.items():
    print(k, ":", v)

print("\nTop folders:")
c2 = Counter(r["top_folder"] for r in rows)
for k, v in c2.most_common():
    print(k, ":", v)

audio = [r for r in rows if r["is_audio"]]
print("\nAudio count:", len(audio))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import re
from pathlib import Path

ROOT = Path("./exemple/PLAINTES/Pieces")
OUT = Path("./data/evidence_engine_v2/live_manifest_v1.json")

IGNORED_FILENAMES = {
    ".DS_Store",
}

def parse_name(filename: str):
    """
    Attend de préférence un format :
    YYYY-MM-DD_P00001_label.ext
    ou
    undated_P00001_label.ext
    """
    p = Path(filename)
    stem = p.stem
    ext = p.suffix.lower()

    m = re.match(r"^(?P<date>(?:\d{4}-\d{2}-\d{2}|undated))_(?P<piece_id>P\d{5})_(?P<label>.+)quot;, stem)
    if m:
        return {
            "date_prefix": m.group("date"),
            "piece_id": m.group("piece_id"),
            "label": m.group("label"),
            "extension": ext,
            "parsed_ok": True,
        }

    return {
        "date_prefix": None,
        "piece_id": None,
        "label": stem,
        "extension": ext,
        "parsed_ok": False,
    }

def top_folder_of(path: Path):
    rel = path.relative_to(ROOT)
    return rel.parts[0] if rel.parts else ""

def relative_dir_of(path: Path):
    rel = path.relative_to(ROOT)
    if len(rel.parts) <= 1:
        return ""
    return str(Path(*rel.parts[:-1]))

rows = []

for p in sorted(ROOT.rglob("*")):
    if not p.is_file():
        continue
    if p.name in IGNORED_FILENAMES:
        continue

    parsed = parse_name(p.name)

    rows.append({
        "path": str(p),
        "filename": p.name,
        "extension": parsed["extension"],
        "top_folder": top_folder_of(p),
        "relative_dir": relative_dir_of(p),
        "date_prefix": parsed["date_prefix"],
        "piece_id": parsed["piece_id"],
        "label": parsed["label"],
        "parsed_ok": parsed["parsed_ok"],
        "size_bytes": p.stat().st_size,
    })

OUT.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

print("Saved:", OUT)
print("Files:", len(rows))
print("Parsed OK:", sum(1 for r in rows if r["parsed_ok"]))
print("Unparsed:", sum(1 for r in rows if not r["parsed_ok"]))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path

ROOT = Path("./exemple/PLAINTES/Pieces")

OUT = Path("./data/evidence_engine_v2/live_manifest_v2.json")

def parse_filename(p: Path):
    name = p.name

    parts = name.split("_")

    date = None
    piece_id = None

    if len(parts) >= 2:
        if parts[0].count("-") == 2:
            date = parts[0]

        if parts[1].startswith("P"):
            piece_id = parts[1]

    return date, piece_id

rows = []

for p in ROOT.rglob("*"):
    if not p.is_file():
        continue

    date, piece_id = parse_filename(p)

    rows.append({
        "path": str(p),
        "filename": p.name,
        "extension": p.suffix.lower(),
        "top_folder": p.parts[len(ROOT.parts)] if len(p.parts) > len(ROOT.parts) else None,
        "relative_dir": str(p.parent.relative_to(ROOT)),
        "date": date,
        "piece_id": piece_id,
        "parsed_ok": bool(piece_id)
    })

OUT.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

print("Saved:", OUT)
print("Files:", len(rows))
print("Parsed OK:", sum(1 for r in rows if r["parsed_ok"]))
print("Unparsed:", sum(1 for r in rows if not r["parsed_ok"]))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from collections import defaultdict
from pathlib import Path

INPUT_PATH = Path("./data/evidence_engine_v2/evidence_index_resynced.json")
OUTPUT_PATH = Path("./data/evidence_engine_v2/duplicate_report_v2.json")


def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    by_hash = defaultdict(list)
    by_label_size = defaultdict(list)

    for item in data:
        sha = item.get("sha256")
        if sha:
            by_hash[sha].append(item)

        key = (
            (item.get("label") or "").strip().lower(),
            item.get("size_bytes"),
            item.get("media_type"),
        )
        by_label_size[key].append(item)

    exact_groups = [v for v in by_hash.values() if len(v) > 1]
    probable_groups = [v for v in by_label_size.values() if len(v) > 1]

    report = {
        "exact_duplicates_count": len(exact_groups),
        "probable_duplicates_count": len(probable_groups),
        "exact_duplicates": exact_groups,
        "probable_duplicates": probable_groups,
    }

    OUTPUT_PATH.write_text(
        json.dumps(report, indent=2, ensure_ascii=False),
        encoding="utf-8"
    )

    print(f"Saved: {OUTPUT_PATH.resolve()}")
    print(f"Exact duplicate groups: {len(exact_groups)}")
    print(f"Probable duplicate groups: {len(probable_groups)}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import hashlib
from pathlib import Path


OLD_INDEX = Path("./data/evidence_engine_v2/evidence_index.json")
OUTPUT = Path("./data/evidence_engine_v2/evidence_index_resynced.json")
ROOT = Path("./exemple/PLAINTES")


def sha256_file(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(1024 * 1024), b""):
            h.update(chunk)
    return h.hexdigest()


def load_json(path: Path):
    return json.loads(path.read_text(encoding="utf-8"))


def main():
    old_data = load_json(OLD_INDEX)

    print("Scan des fichiers actuels...")
    current_files = [p for p in ROOT.rglob("*") if p.is_file() and p.name != ".DS_Store"]

    current_by_hash = {}
    for p in current_files:
        try:
            current_by_hash[sha256_file(p)] = str(p)
        except Exception:
            pass

    updated = []
    found = 0
    missing = 0

    for item in old_data:
        sha = item.get("sha256")
        old_path = item.get("original_path")
        new_path = current_by_hash.get(sha)

        if new_path:
            item["original_path"] = new_path
            found += 1
        else:
            item["missing_path"] = old_path
            missing += 1

        updated.append(item)

    OUTPUT.write_text(json.dumps(updated, indent=2, ensure_ascii=False), encoding="utf-8")

    print(f"Resynced file saved to: {OUTPUT}")
    print(f"Matched: {found}")
    print(f"Missing: {missing}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from collections import Counter
from pathlib import Path

p = Path("./data/evidence_engine/evidence_index.json")
data = json.loads(p.read_text(encoding="utf-8"))

print("Total:", len(data))
print("\nMedia types:")
for k, v in Counter(item["media_type"] for item in data).most_common():
    print(f"{k}: {v}")

print("\nWith extracted text:")
count_text = sum(1 for item in data if item.get("text_path"))
print(count_text)

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from collections import Counter
from pathlib import Path

p = Path("./data/evidence_engine_v2/evidence_index.json")
data = json.loads(p.read_text(encoding="utf-8"))

print("TOTAL:", len(data))
print("\nMEDIA TYPES:")
for k, v in Counter(item["media_type"] for item in data).most_common():
    print(f"{k}: {v}")

without_text = [x for x in data if not x.get("text_path")]
print("\nWITHOUT TEXT:", len(without_text))

print("\nFIRST 20 WITHOUT TEXT:")
for item in without_text[:20]:
    print(item["evidence_id"], item["media_type"], item["label"])

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path

p = Path("./data/evidence_engine_v2/subset_transcriptions_manifest_v2.json")
if p.exists():
    data = json.loads(p.read_text(encoding="utf-8"))
    ok = sum(1 for x in data if x["status"] == "ok")
    print("DONE:", ok)
else:
    print("manifest not yet created")

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import pytesseract
from PIL import Image

def ocr_image(path):
    return pytesseract.image_to_string(Image.open(path))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from pypdf import PdfReader

def read_pdf(path):
    reader = PdfReader(path)
    text = ""
    for page in reader.pages:
        text += page.extract_text() or ""
    return text

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import whisper

model = whisper.load_model("base")

def transcribe(file):
    result = model.transcribe(file)
    return result["text"]

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from __future__ import annotations

import argparse
import json
from collections import defaultdict
from pathlib import Path


def main() -> None:
    parser = argparse.ArgumentParser(description="Trouver les doublons dans evidence_index.json")
    parser.add_argument("--index", required=True, help="Chemin vers evidence_index.json")
    parser.add_argument("--output", default="./data/evidence_engine_v2/duplicate_report.json", help="Rapport de sortie")
    args = parser.parse_args()

    index_path = Path(args.index).expanduser().resolve()
    output_path = Path(args.output).expanduser().resolve()

    data = json.loads(index_path.read_text(encoding="utf-8"))

    by_hash = defaultdict(list)
    by_name_size = defaultdict(list)

    for item in data:
        sha = item.get("sha256")
        if sha:
            by_hash[sha].append(item)

        key = (item.get("label"), item.get("size_bytes"))
        by_name_size[key].append(item)

    exact_duplicates = [group for group in by_hash.values() if len(group) > 1]
    probable_duplicates = [group for group in by_name_size.values() if len(group) > 1]

    report = {
        "exact_duplicates_count": len(exact_duplicates),
        "probable_duplicates_count": len(probable_duplicates),
        "exact_duplicates": exact_duplicates,
        "probable_duplicates": probable_duplicates,
    }

    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")

    print(f"Exact duplicates groups: {len(exact_duplicates)}")
    print(f"Probable duplicates groups: {len(probable_duplicates)}")
    print(f"Saved report to: {output_path}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import os
import json
from datetime import datetime

BASE_DIR = "./preuves"
OUTPUT = "./data/evidence_index.json"

def detect_type(filename):
    ext = filename.lower().split(".")[-1]
    if ext in ["jpg", "png", "jpeg"]:
        return "image"
    if ext in ["mp3", "wav", "m4a"]:
        return "audio"
    if ext in ["mp4", "mov"]:
        return "video"
    if ext in ["pdf"]:
        return "pdf"
    if ext in ["txt"]:
        return "text"
    return "other"

def generate_id(i):
    return f"P{str(i).zfill(4)}"

def scan():
    index = []
    counter = 1

    for root, _, files in os.walk(BASE_DIR):
        for file in files:
            path = os.path.join(root, file)

            entry = {
                "id": generate_id(counter),
                "file": file,
                "path": path,
                "type": detect_type(file),
                "date": None,
                "tags": []
            }

            index.append(entry)
            counter += 1

    return index

def save(index):
    os.makedirs("./data", exist_ok=True)
    with open(OUTPUT, "w") as f:
        json.dump(index, f, indent=2)

if __name__ == "__main__":
    data = scan()
    save(data)
    print(f"Indexed {len(data)} files")

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import shutil
from pathlib import Path

BASE = Path("./data/evidence_engine_v2")
MAPPING = BASE / "case_mapping.json"

TARGET = Path("./exemple/PLAINTES/PIECES_PAR_INFRACTION")
TARGET.mkdir(parents=True, exist_ok=True)

data = json.loads(MAPPING.read_text(encoding="utf-8"))

for item in data:
    if item["missing"]:
        continue

    src = Path(item["source_path"])
    if not src.exists():
        continue

    infra = item.get("infraction") or "non_classe"
    folder = TARGET / infra
    folder.mkdir(exist_ok=True)

    dst = folder / src.name

    try:
        shutil.copy2(src, dst)
    except:
        pass

print("Done")

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path
import os

BASE = Path("./data/evidence_engine_v2")
MAPPING = BASE / "v3_reports/case_mapping_enriched.json"

TARGET = Path("./exemple/PLAINTES/PIECES_PAR_INFRACTION_LINKS")
TARGET.mkdir(parents=True, exist_ok=True)


def safe_name(text):
    if not text:
        return "non_classe"
    return (
        text.replace("/", "-")
            .replace("\\", "-")
            .replace(":", " -")
            .strip()
    )


data = json.loads(MAPPING.read_text(encoding="utf-8"))

count = 0
skipped = 0

for item in data:
    if item.get("missing"):
        skipped += 1
        continue

    src = Path(item["source_path"])
    if not src.exists():
        skipped += 1
        continue

    legal_tags = item.get("legal_tags", []) or ["non_classe"]

    for infra in legal_tags:
        folder = TARGET / safe_name(infra)
        folder.mkdir(parents=True, exist_ok=True)

        dst = folder / src.name

        # éviter collisions
        if dst.exists():
            stem = dst.stem
            suffix = dst.suffix
            i = 2
            while True:
                candidate = folder / f"{stem}__{item['event_id']}_{i}{suffix}"
                if not candidate.exists():
                    dst = candidate
                    break
                i += 1

        try:
            os.symlink(src, dst)
            count += 1
        except FileExistsError:
            pass
        except OSError:
            skipped += 1

print(f"Liens créés : {count}")
print(f"Ignorés : {skipped}")
print(f"Dossier : {TARGET}")

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import re
import unicodedata
import shutil
from pathlib import Path
from datetime import datetime

INPUT_PATH = Path("./data/evidence_engine_v2/v3_reports/case_mapping_enriched.json")
TARGET = Path("./exemple/PLAINTES/Pieces_renamed_v3")
TARGET.mkdir(parents=True, exist_ok=True)

GENERIC_PREFIXES = (
    "capture d’écran",
    "capture d'ecran",
    "capture decran",
    "capture",
    "screenshot",
    "img_",
    "pxl_",
)

def strip_accents(text: str) -> str:
    text = unicodedata.normalize("NFKD", text)
    return "".join(c for c in text if not unicodedata.combining(c))

def slugify(text: str) -> str:
    text = (text or "").strip().lower()
    text = strip_accents(text)

    text = text.replace("capture d'ecran", "capture")
    text = text.replace("capture decran", "capture")
    text = text.replace("capture d ecran", "capture")
    text = text.replace("screenshot", "capture")

    text = re.sub(r"\.(pdf|jpg|jpeg|png|webp|docx|doc|mp3|m4a|wav|html)quot;, "", text)

    text = re.sub(
        r"capture[-\s_]*(\d{4}-\d{2}-\d{2})[-\s_]*a[-\s_]*(\d{2})[.\-_:](\d{2})[.\-_:](\d{2})",
        r"capture-\2-\3-\4",
        text,
    )

    text = re.sub(
        r"capture[-\s_]*(\d{8})[-_](\d{6})(?:[-\s_]+)?(.*)",
        lambda m: f"capture-{m.group(2)[0:2]}-{m.group(2)[2:4]}-{m.group(2)[4:6]}" + (f"-{m.group(3).strip()}" if m.group(3).strip() else ""),
        text,
    )

    text = re.sub(r"\b20\d{2}-\d{2}-\d{2}\b", "", text)
    text = re.sub(r"\b20\d{8,}\b", "", text)

    text = re.sub(r"[^\w\s-]", " ", text)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")

    text = text.replace("capture-d-ecran-a-", "capture-")
    text = text.replace("capture-d-ecran-", "capture-")
    text = text.replace("capture-a-", "capture-")

    return text[:90] or "piece"

def is_generic_name(src: Path) -> bool:
    stem = strip_accents(src.stem.lower().strip())
    return (
        stem.startswith(GENERIC_PREFIXES)
        or re.match(r"^(img|pxl)[-_]?\d+", stem) is not None
    )

def is_valid_date(y: str, m: str, d: str) -> bool:
    try:
        datetime(int(y), int(m), int(d))
        return True
    except ValueError:
        return False

def extract_date_from_filename(name: str):
    patterns = [
        r"(20\d{2})[-_](\d{2})[-_](\d{2})",
        r"(20\d{2})(\d{2})(\d{2})",
        r"(\d{2})[-_](\d{2})[-_](20\d{2})",
    ]

    for pat in patterns:
        m = re.search(pat, name)
        if not m:
            continue
        g = m.groups()

        if len(g) == 3 and len(g[0]) == 4:
            y, mo, d = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

        if len(g) == 3 and len(g[2]) == 4:
            d, mo, y = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

    return None

def extract_date_from_stat(src: Path):
    try:
        ts = src.stat().st_mtime
        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d")
    except Exception:
        return None

def best_date(item, src: Path):
    d = item.get("date")
    if d and d != "undated":
        return d

    d = extract_date_from_filename(src.name)
    if d:
        return d

    d = extract_date_from_stat(src)
    if d:
        return d

    return "undated"

def best_label(item, src: Path, date: str):
    label = (item.get("label") or "").strip()
    src_stem = src.stem.strip()

    base = label or src_stem
    if not is_generic_name(src):
        base = src_stem

    clean = slugify(base)

    if date and date != "undated":
        clean = clean.replace(date, "").strip("-")
        clean = re.sub(rf"{re.escape(date)}pdf\b", "", clean).strip("-")

    return clean or "piece"

def normalized_suffix(src: Path) -> str:
    name = src.name.lower()
    if name.endswith(".pdf.pdf"):
        return ".pdf"
    return src.suffix.lower()

def make_new_name(item):
    src = Path(item["source_path"])
    event_id = item.get("event_id") or "PX"
    date = best_date(item, src)
    label = best_label(item, src, date)
    suffix = normalized_suffix(src)
    return f"{date}_{event_id}_{label}{suffix}"

def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    copied = 0
    skipped_missing = 0
    skipped_exists = 0

    for item in data:
        if item.get("missing") or not item.get("source_path"):
            skipped_missing += 1
            continue

        src = Path(item["source_path"])
        if not src.exists():
            skipped_missing += 1
            continue

        new_name = make_new_name(item)
        dst = TARGET / new_name

        if dst.exists():
            skipped_exists += 1
            continue

        shutil.copy2(src, dst)
        copied += 1

    print("Target:", TARGET)
    print("Copied:", copied)
    print("Skipped missing:", skipped_missing)
    print("Skipped existing:", skipped_exists)

if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import shutil
from pathlib import Path
import re

BASE = Path("./data/evidence_engine_v2")
MAPPING = BASE / "case_mapping.json"

TARGET = Path("./exemple/PLAINTES/Pieces_renamed")
TARGET.mkdir(parents=True, exist_ok=True)

def clean(text):
    text = text.lower()
    text = re.sub(r"[^\w\s-]", "", text)
    text = re.sub(r"\s+", "_", text)
    return text[:80]

data = json.loads(MAPPING.read_text(encoding="utf-8"))

for item in data:
    if item["missing"]:
        continue
    
    src = Path(item["source_path"])
    if not src.exists():
        continue

    ext = src.suffix
    label = clean(item["label"])
    date = item["date"] or "unknown"

    new_name = f"{item['event_id']}_{date}_{label}{ext}"
    dst = TARGET / new_name

    try:
        shutil.copy2(src, dst)
    except:
        pass

print("Renamed files saved to:", TARGET)

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import re
import unicodedata
import csv
from pathlib import Path
from datetime import datetime

INPUT_PATH = Path("./data/evidence_engine_v2/v3_reports/case_mapping_enriched.json")
LOG_PATH = Path("./data/evidence_engine_v2/rename_in_place_v3_log.csv")

GENERIC_PREFIXES = (
    "capture d’écran",
    "capture d'ecran",
    "capture decran",
    "capture",
    "screenshot",
    "img_",
    "pxl_",
)

def strip_accents(text: str) -> str:
    text = unicodedata.normalize("NFKD", text)
    return "".join(c for c in text if not unicodedata.combining(c))

def slugify(text: str) -> str:
    text = (text or "").strip().lower()
    text = strip_accents(text)

    text = text.replace("capture d'ecran", "capture")
    text = text.replace("capture decran", "capture")
    text = text.replace("capture d ecran", "capture")
    text = text.replace("screenshot", "capture")

    # cas photos Pixel / IMG
    text = re.sub(
        r"^pxl[-_]?(\d{4})(\d{2})(\d{2})[-_]?(\d{2})(\d{2})(\d{2})\d*quot;,
        r"photo-\4-\5-\6",
        text,
    )

    text = re.sub(
        r"^img[-_]?(\d{4})(\d{2})(\d{2})[-_]?(\d{2})(\d{2})(\d{2}).*quot;,
        r"photo-\4-\5-\6",
        text,
    )

    text = re.sub(r"\.(pdf|jpg|jpeg|png|webp|docx|doc|mp3|m4a|wav|html|txt)quot;, "", text)

    # captures avec date + heure
    text = re.sub(
        r"capture[-\s_]*(\d{4}-\d{2}-\d{2})[-\s_]*a[-\s_]*(\d{2})[.\-_:](\d{2})[.\-_:](\d{2})",
        r"capture-\2-\3-\4",
        text,
    )

    # screenshot format
    text = re.sub(
        r"capture[-\s_]*(\d{8})[-_](\d{6})(?:[-\s_]+)?(.*)",
        lambda m: f"capture-{m.group(2)[0:2]}-{m.group(2)[2:4]}-{m.group(2)[4:6]}" + (f"-{m.group(3).strip()}" if m.group(3).strip() else ""),
        text,
    )

    text = re.sub(r"\b20\d{2}-\d{2}-\d{2}\b", "", text)
    text = re.sub(r"\b20\d{8,}\b", "", text)

    text = re.sub(r"[^\w\s-]", " ", text)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")

    text = text.replace("capture-d-ecran-a-", "capture-")
    text = text.replace("capture-d-ecran-", "capture-")
    text = text.replace("capture-a-", "capture-")

    return text[:90] or "piece"

def is_generic_name(src: Path) -> bool:
    stem = strip_accents(src.stem.lower().strip())
    return (
        stem.startswith(GENERIC_PREFIXES)
        or re.match(r"^(img|pxl)[-_]?\d+", stem) is not None
    )

def is_valid_date(y: str, m: str, d: str) -> bool:
    try:
        datetime(int(y), int(m), int(d))
        return True
    except ValueError:
        return False

def extract_date_from_filename(name: str):
    patterns = [
        r"(20\d{2})[-_](\d{2})[-_](\d{2})",
        r"(20\d{2})(\d{2})(\d{2})",
        r"(\d{2})[-_](\d{2})[-_](20\d{2})",
    ]

    for pat in patterns:
        m = re.search(pat, name)
        if not m:
            continue
        g = m.groups()

        if len(g) == 3 and len(g[0]) == 4:
            y, mo, d = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

        if len(g) == 3 and len(g[2]) == 4:
            d, mo, y = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

    return None

def extract_date_from_stat(src: Path):
    try:
        ts = src.stat().st_mtime
        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d")
    except Exception:
        return None

def best_date(item, src: Path):
    d = item.get("date")
    if d and d != "undated":
        return d

    d = extract_date_from_filename(src.name)
    if d:
        return d

    d = extract_date_from_stat(src)
    if d:
        return d

    return "undated"

def best_label(item, src: Path, date: str):
    label = (item.get("label") or "").strip()
    src_stem = src.stem.strip()

    base = label or src_stem
    if not is_generic_name(src):
        base = src_stem

    clean = slugify(base)

    if date and date != "undated":
        clean = clean.replace(date, "").strip("-")
        clean = re.sub(rf"{re.escape(date)}pdf\b", "", clean).strip("-")

    return clean or "piece"

def normalized_suffix(src: Path) -> str:
    name = src.name.lower()
    if name.endswith(".pdf.pdf"):
        return ".pdf"

    suffix = src.suffix.lower()
    known = {
        ".pdf", ".jpg", ".jpeg", ".png", ".webp",
        ".doc", ".docx", ".mp3", ".m4a", ".wav",
        ".html", ".txt"
    }
    if suffix in known:
        return suffix
    return suffix if suffix.startswith(".") else f".{suffix}"

def make_new_name(item):
    src = Path(item["source_path"])
    event_id = item.get("event_id") or "PX"
    date = best_date(item, src)
    label = best_label(item, src, date)
    suffix = normalized_suffix(src)
    return f"{date}_{event_id}_{label}{suffix}"

def uniquify_in_dir(dst: Path) -> Path:
    if not dst.exists():
        return dst

    stem = dst.stem
    suffix = dst.suffix
    parent = dst.parent
    i = 2
    while True:
        candidate = parent / f"{stem}__dup{i}{suffix}"
        if not candidate.exists():
            return candidate
        i += 1

def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    renamed = 0
    skipped_missing = 0
    skipped_same = 0
    rows = []

    for item in data:
        if item.get("missing") or not item.get("source_path"):
            skipped_missing += 1
            continue

        src = Path(item["source_path"])
        if not src.exists():
            skipped_missing += 1
            continue

        new_name = make_new_name(item)
        dst = src.with_name(new_name)
        dst = uniquify_in_dir(dst)

        if src == dst:
            skipped_same += 1
            rows.append({
                "status": "same_name",
                "old_path": str(src),
                "new_path": str(dst),
            })
            continue

        try:
            src.rename(dst)
            renamed += 1
            rows.append({
                "status": "renamed",
                "old_path": str(src),
                "new_path": str(dst),
            })
        except Exception as e:
            rows.append({
                "status": f"error: {e}",
                "old_path": str(src),
                "new_path": str(dst),
            })

    with LOG_PATH.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["status", "old_path", "new_path"])
        writer.writeheader()
        writer.writerows(rows)

    print("Log:", LOG_PATH)
    print("Renamed:", renamed)
    print("Skipped missing:", skipped_missing)
    print("Skipped same:", skipped_same)

if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import re
import unicodedata
from pathlib import Path
from datetime import datetime

INPUT_PATH = Path("./data/evidence_engine_v2/v3_reports/case_mapping_enriched.json")

GENERIC_PREFIXES = (
    "capture d’écran",
    "capture d'ecran",
    "capture decran",
    "capture",
    "screenshot",
    "img_",
    "pxl_",
)

def strip_accents(text: str) -> str:
    text = unicodedata.normalize("NFKD", text)
    return "".join(c for c in text if not unicodedata.combining(c))

def slugify(text: str) -> str:
    text = (text or "").strip().lower()
    text = strip_accents(text)

    text = text.replace("capture d'ecran", "capture")
    text = text.replace("capture decran", "capture")
    text = text.replace("capture d ecran", "capture")
    text = text.replace("screenshot", "capture")

    # cas photos Pixel / IMG
    text = re.sub(
        r"^pxl[-_]?(\d{4})(\d{2})(\d{2})[-_]?(\d{2})(\d{2})(\d{2})\d*quot;,
        r"photo-\4-\5-\6",
        text,
    )

    text = re.sub(
        r"^img[-_]?(\d{4})(\d{2})(\d{2})[-_]?(\d{2})(\d{2})(\d{2}).*quot;,
        r"photo-\4-\5-\6",
        text,
    )

    # enlever extensions dans le label
    text = re.sub(r"\.(pdf|jpg|jpeg|png|webp|docx|doc|mp3|m4a|wav|html)quot;, "", text)

    # captures avec date + heure
    text = re.sub(
        r"capture[-\s_]*(\d{4}-\d{2}-\d{2})[-\s_]*a[-\s_]*(\d{2})[.\-_:](\d{2})[.\-_:](\d{2})",
        r"capture-\2-\3-\4",
        text,
    )

    # screenshot format
    text = re.sub(
        r"capture[-\s_]*(\d{8})[-_](\d{6})(?:[-\s_]+)?(.*)",
        lambda m: f"capture-{m.group(2)[0:2]}-{m.group(2)[2:4]}-{m.group(2)[4:6]}" + (f"-{m.group(3).strip()}" if m.group(3).strip() else ""),
        text,
    )

    # enlever dates redondantes
    text = re.sub(r"\b20\d{2}-\d{2}-\d{2}\b", "", text)
    text = re.sub(r"\b20\d{8,}\b", "", text)

    # nettoyage final
    text = re.sub(r"[^\w\s-]", " ", text)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")

    text = text.replace("capture-d-ecran-a-", "capture-")
    text = text.replace("capture-d-ecran-", "capture-")
    text = text.replace("capture-a-", "capture-")

    return text[:90] or "piece"

def is_generic_name(src: Path) -> bool:
    stem = strip_accents(src.stem.lower().strip())
    return (
        stem.startswith(GENERIC_PREFIXES)
        or re.match(r"^(img|pxl)[-_]?\d+", stem) is not None
    )

def is_valid_date(y: str, m: str, d: str) -> bool:
    try:
        datetime(int(y), int(m), int(d))
        return True
    except ValueError:
        return False

def extract_date_from_filename(name: str):
    patterns = [
        r"(20\d{2})[-_](\d{2})[-_](\d{2})",
        r"(20\d{2})(\d{2})(\d{2})",
        r"(\d{2})[-_](\d{2})[-_](20\d{2})",
    ]

    for pat in patterns:
        m = re.search(pat, name)
        if not m:
            continue
        g = m.groups()

        if len(g) == 3 and len(g[0]) == 4:
            y, mo, d = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

        if len(g) == 3 and len(g[2]) == 4:
            d, mo, y = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

    return None

def extract_date_from_stat(src: Path):
    try:
        ts = src.stat().st_mtime
        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d")
    except Exception:
        return None

def best_date(item, src: Path):
    # 1) mapping
    d = item.get("date")
    if d and d != "undated":
        return d

    # 2) nom du fichier
    d = extract_date_from_filename(src.name)
    if d:
        return d

    # 3) date filesystem
    d = extract_date_from_stat(src)
    if d:
        return d

    return "undated"

def best_label(item, src: Path, date: str):
    label = (item.get("label") or "").strip()
    src_stem = src.stem.strip()

    base = label or src_stem

    # si le nom source est déjà humain, on le privilégie
    if not is_generic_name(src):
        base = src_stem

    clean = slugify(base)

    # enlever la date si elle est déjà en tête du nom final
    if date and date != "undated":
        clean = clean.replace(date, "").strip("-")

    # enlever résidus de type "2025-11-05pdf"
    clean = re.sub(rf"{re.escape(date)}pdf\b", "", clean).strip("-") if date != "undated" else clean

    return clean or "piece"

def normalized_suffix(src: Path) -> str:
    name = src.name.lower()

    if name.endswith(".pdf.pdf"):
        return ".pdf"

    suffix = src.suffix.lower()

    # garde uniquement des extensions simples connues
    known = {
        ".pdf", ".jpg", ".jpeg", ".png", ".webp",
        ".doc", ".docx", ".mp3", ".m4a", ".wav",
        ".html", ".txt"
    }

    if suffix in known:
        return suffix

    # fallback défensif
    return suffix if suffix.startswith(".") else f".{suffix}"

def make_new_name(item):
    src = Path(item["source_path"])
    event_id = item.get("event_id") or "PX"
    date = best_date(item, src)
    label = best_label(item, src, date)
    suffix = normalized_suffix(src)

    return f"{date}_{event_id}_{label}{suffix}"

def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    print("DRY RUN — aucun fichier n'est déplacé.")
    for item in data[:150]:
        if item.get("missing") or not item.get("source_path"):
            continue
        src = Path(item["source_path"])
        print(f"{src.name} -> {make_new_name(item)}")

    print("\nQuand la preview sera validée, on fera la version apply.")

if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import re
import shutil
import unicodedata
from pathlib import Path

INPUT_PATH = Path("./data/evidence_engine_v2/v3_reports/case_mapping_enriched.json")

def slugify(text):
    text = (text or "").lower()

    # harmonisation unicode/apostrophes visuelles simples
    text = text.replace("d’écran", "ecran")
    text = text.replace("d'écran", "ecran")
    text = text.replace("capture d’écran", "capture")
    text = text.replace("capture d'écran", "capture")
    text = text.replace("capture decran", "capture")
    text = text.replace("screenshot", "capture")

    # cas: "capture 2000-01-01 a 12.00.00"
    text = re.sub(
        r"capture[-\s_]*(\d{4}-\d{2}-\d{2})[-\s_]*a[-\s_]*(\d{2})[.\-_:](\d{2})[.\-_:](\d{2})",
        r"capture-\2\3\4",
        text,
    )

    # cas: "capture 20000101-120000 messages"
    text = re.sub(
        r"capture[-\s_]*(\d{8})[-_](\d{6})(?:[-\s_]+)?(.*)",
        lambda m: f"capture-{m.group(2)}" + (f"-{m.group(3).strip()}" if m.group(3).strip() else ""),
        text,
    )

    # si on a encore une date redondante après "capture-"
    text = re.sub(r"capture-(\d{4}-\d{2}-\d{2})-a-", "capture-", text)
    text = re.sub(r"capture-(\d{8})-", "capture-", text)

    # nettoyage général
    text = re.sub(r"[^\w\s-]", "", text)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")

    # enlever répétitions trop verbeuses
    text = text.replace("capture-a-", "capture-")
    text = text.replace("capture-ecran-", "capture-")

    return text[:60] or "piece"

def make_new_name(item):
    date = item.get("date") or "undated"
    media_type = item.get("media_type") or "file"
    label = slugify(item.get("label") or "")
    event_id = item.get("event_id") or "PX"
    src = Path(item["source_path"])

    # petite simplification visuelle pour les captures image
    if media_type == "image" and label.startswith("capture-"):
        return f"{date}_{media_type}_{event_id}_{label}{src.suffix.lower()}"

    return f"{date}_{media_type}_{event_id}_{label}{src.suffix.lower()}"

def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    print("DRY RUN — aucun fichier n'est déplacé.")
    for item in data[:100]:
        if item.get("missing") or not item.get("source_path"):
            continue
        src = Path(item["source_path"])
        new_name = make_new_name(item)
        print(src.name, "->", new_name)

    print("\nQuand la transcription sera finie, on ajoutera le vrai déplacement.")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import re
import csv
import unicodedata
from pathlib import Path
from datetime import datetime

ROOT = Path("./exemple/PLAINTES/Pieces")
LOG_PATH = Path("./data/evidence_engine_v2/rename_live_tree_files_only_log.csv")

ALLOWED_TOP_DIRS = {'04.AUDIO', '05.PROCEDURES', '02.DOCUMENTS', '03.ECHANGES', '01.ATTESTATIONS', '00.RECAP'}

IGNORED_FILENAMES = {
    ".DS_Store",
}

def strip_accents(text: str) -> str:
    text = unicodedata.normalize("NFKD", text)
    return "".join(c for c in text if not unicodedata.combining(c))

def is_valid_date(y: str, m: str, d: str) -> bool:
    try:
        datetime(int(y), int(m), int(d))
        return True
    except ValueError:
        return False

def extract_date_from_filename(name: str):
    patterns = [
        r"(20\d{2})[-_](\d{2})[-_](\d{2})",
        r"(20\d{2})(\d{2})(\d{2})",
        r"(\d{2})[-_](\d{2})[-_](20\d{2})",
    ]

    for pat in patterns:
        m = re.search(pat, name)
        if not m:
            continue
        g = m.groups()

        if len(g) == 3 and len(g[0]) == 4:
            y, mo, d = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

        if len(g) == 3 and len(g[2]) == 4:
            d, mo, y = g
            if is_valid_date(y, mo, d):
                return f"{y}-{mo}-{d}"

    return None

def extract_date_from_stat(src: Path):
    try:
        ts = src.stat().st_mtime
        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d")
    except Exception:
        return None

def best_date(src: Path):
    d = extract_date_from_filename(src.name)
    if d:
        return d

    d = extract_date_from_stat(src)
    if d:
        return d

    return "undated"

def is_capture_name(stem: str) -> bool:
    s = strip_accents(stem.lower())
    return (
        s.startswith("capture d'ecran")
        or s.startswith("capture decran")
        or s.startswith("capture d ecran")
        or s.startswith("capture")
        or s.startswith("screenshot")
    )

def is_phone_photo_name(stem: str) -> bool:
    s = strip_accents(stem.lower())
    return (
        re.match(r"^pxl[-_]?\d+", s) is not None
        or re.match(r"^img[-_]?\d+", s) is not None
    )

def normalize_capture_label(stem: str) -> str:
    s = strip_accents(stem.lower())

    s = s.replace("capture d'ecran", "capture")
    s = s.replace("capture decran", "capture")
    s = s.replace("capture d ecran", "capture")
    s = s.replace("screenshot", "capture")

    # Capture 2000-01-01 a 12.00.00
    m = re.search(r"(\d{2})[.\-_:](\d{2})[.\-_:](\d{2})", s)
    if m:
        hh, mm, ss = m.groups()
        suffix = ""
        # si mots additionnels après l'heure
        tail = s[m.end():].strip(" _-")
        if tail:
            tail = re.sub(r"[^\w\s-]", " ", tail)
            tail = re.sub(r"[\s_-]+", "-", tail).strip("-")
            suffix = f"-{tail}" if tail else ""
        return f"capture-{hh}-{mm}-{ss}{suffix}"

    # screenshot_20000101-120000_messages
    m = re.search(r"(\d{6})(?:[-_\s]+)?(.*)quot;, s)
    if m:
        hhmmss = m.group(1)
        hh, mm, ss = hhmmss[:2], hhmmss[2:4], hhmmss[4:6]
        tail = (m.group(2) or "").strip(" _-")
        if tail:
            tail = re.sub(r"[^\w\s-]", " ", tail)
            tail = re.sub(r"[\s_-]+", "-", tail).strip("-")
            return f"capture-{hh}-{mm}-{ss}-{tail}"
        return f"capture-{hh}-{mm}-{ss}"

    return "capture"

def normalize_photo_label(stem: str) -> str:
    s = strip_accents(stem.lower())

    m = re.match(r"^pxl[-_]?(\d{4})(\d{2})(\d{2})[-_]?(\d{2})(\d{2})(\d{2})\d*quot;, s)
    if m:
        return f"photo-{m.group(4)}-{m.group(5)}-{m.group(6)}"

    m = re.match(r"^img[-_]?(\d{4})(\d{2})(\d{2})[-_]?(\d{2})(\d{2})(\d{2}).*quot;, s)
    if m:
        return f"photo-{m.group(4)}-{m.group(5)}-{m.group(6)}"

    return "photo"

def slugify_human_label(stem: str, date: str) -> str:
    s = strip_accents(stem.lower())

    # enlever extensions textuelles résiduelles
    s = re.sub(r"\.(pdf|jpg|jpeg|png|webp|docx|doc|mp3|m4a|wav|html|txt)quot;, "", s)

    if date != "undated":
        s = s.replace(date, "")
        s = re.sub(rf"{re.escape(date)}pdf\b", "", s)

    s = re.sub(r"[^\w\s-]", " ", s)
    s = re.sub(r"[\s_-]+", "-", s).strip("-")

    return s[:90] or "piece"

def normalized_suffix(src: Path) -> str:
    name = src.name.lower()
    if name.endswith(".pdf.pdf"):
        return ".pdf"

    suffix = src.suffix.lower()
    known = {
        ".pdf", ".jpg", ".jpeg", ".png", ".webp",
        ".doc", ".docx", ".mp3", ".m4a", ".wav",
        ".html", ".txt", ".mov", ".mp4"
    }
    if suffix in known:
        return suffix
    return suffix if suffix.startswith(".") else f".{suffix}"

def build_new_name(src: Path, piece_id: str) -> str:
    date = best_date(src)
    stem = src.stem

    if is_capture_name(stem):
        label = normalize_capture_label(stem)
    elif is_phone_photo_name(stem):
        label = normalize_photo_label(stem)
    else:
        label = slugify_human_label(stem, date)

    suffix = normalized_suffix(src)
    return f"{date}_{piece_id}_{label}{suffix}"

def top_dir_name(path: Path):
    try:
        rel = path.relative_to(ROOT)
    except ValueError:
        return None
    parts = rel.parts
    return parts[0] if parts else None

def should_process(path: Path) -> bool:
    if not path.is_file():
        return False
    if path.name in IGNORED_FILENAMES:
        return False

    top = top_dir_name(path)
    if top is None:
        return False

    normalized_top = top.upper()
    allowed_upper = {x.upper() for x in ALLOWED_TOP_DIRS}
    return normalized_top in allowed_upper

def uniquify_in_dir(dst: Path) -> Path:
    if not dst.exists():
        return dst

    stem = dst.stem
    suffix = dst.suffix
    parent = dst.parent
    i = 2
    while True:
        candidate = parent / f"{stem}__dup{i}{suffix}"
        if not candidate.exists():
            return candidate
        i += 1

def collect_files():
    files = []
    for p in ROOT.rglob("*"):
        if should_process(p):
            files.append(p)
    return sorted(files)

def main():
    files = collect_files()

    rows = []
    renamed = 0
    skipped_same = 0
    errors = 0

    for idx, src in enumerate(files, start=1):
        piece_id = f"P{idx:05d}"
        new_name = build_new_name(src, piece_id)
        dst = src.with_name(new_name)
        dst = uniquify_in_dir(dst)

        if src == dst:
            skipped_same += 1
            rows.append({
                "status": "same_name",
                "old_path": str(src),
                "new_path": str(dst),
            })
            continue

        try:
            src.rename(dst)
            renamed += 1
            rows.append({
                "status": "renamed",
                "old_path": str(src),
                "new_path": str(dst),
            })
        except Exception as e:
            errors += 1
            rows.append({
                "status": f"error: {e}",
                "old_path": str(src),
                "new_path": str(dst),
            })

    with LOG_PATH.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["status", "old_path", "new_path"])
        writer.writeheader()
        writer.writerows(rows)

    print("Root:", ROOT)
    print("Log:", LOG_PATH)
    print("Renamed:", renamed)
    print("Skipped same:", skipped_same)
    print("Errors:", errors)

if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
# Emplacement d’origine omis dans cette copie de consultation.


import json
from pathlib import Path

INDEX_PATH = Path("./data/evidence_engine_v2/evidence_index_resynced.json")
MANIFEST_PATH = Path("./data/evidence_engine_v2/subset_transcriptions_manifest_v2.json")
OUTPUT_PATH = Path("./data/evidence_engine_v2/case_mapping.json")


def load_json(path):
    if path.exists():
        return json.loads(path.read_text(encoding="utf-8"))
    return []


def main():
    index = load_json(INDEX_PATH)
    manifest = load_json(MANIFEST_PATH)

    trans_map = {
        item["source_path"]: item["transcription_path"]
        for item in manifest
        if item.get("status") == "ok"
    }

    events = []

    for item in index:
        source_path = item.get("original_path")
        missing_path = item.get("missing_path")
        missing = "missing_path" in item

        event = {
            "event_id": item["evidence_id"],
            "label": item.get("label"),
            "date": item.get("guessed_date"),
            "media_type": item.get("media_type"),
            "source_path": None if missing else source_path,
            "missing": missing,
            "missing_path": missing_path if missing else None,
            "transcription": trans_map.get(source_path) if source_path else None,
        }

        events.append(event)

    OUTPUT_PATH.write_text(
        json.dumps(events, indent=2, ensure_ascii=False),
        encoding="utf-8"
    )

    print(f"Saved mapping: {OUTPUT_PATH}")
    print(f"Events: {len(events)}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path
from openpyxl import Workbook
from openpyxl.styles import Font

INPUT_PATH = Path("./data/evidence_engine_v2/v3_reports/case_mapping_enriched.json")
OUTPUT_PATH = Path("./data/evidence_engine_v2/evidence.xlsx")


def make_relative(path_str):
    if not path_str:
        return None

    p = Path(path_str)

    try:
        parts = p.parts
        if "PLAINTES" in parts:
            idx = parts.index("PLAINTES")
            rel = Path(*parts[idx + 1:])
            return Path("Pieces") / rel
    except:
        pass

    return None


def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    wb = Workbook()
    ws = wb.active
    ws.title = "Preuves"

    headers = [
        "ID",
        "Date",
        "Type",
        "Label",
        "Domaine",
        "Infraction",
        "Statut",
        "Fichier",
        "Transcription",
        "Chemin relatif",
        "Ancien chemin"
    ]

    ws.append(headers)

    # style header
    for col in range(1, len(headers) + 1):
        ws.cell(row=1, column=col).font = Font(bold=True)

    for item in data:
        rel_path = make_relative(item.get("source_path"))
        trans_path = make_relative(item.get("transcription"))

        statut = "MISSING" if item.get("missing") else "OK"

        row = [
            item.get("event_id"),
            item.get("date"),
            item.get("media_type"),
            item.get("label"),
            ", ".join(item.get("domains", [])),
            ", ".join(item.get("legal_tags", [])),
            statut,
            None,
            None,
            str(rel_path) if rel_path else None,
            item.get("missing_path"),
        ]

        ws.append(row)
        r = ws.max_row

        # lien fichier
        if rel_path:
            cell = ws.cell(row=r, column=8)
            cell.value = "ouvrir"
            cell.hyperlink = str(rel_path)
            cell.style = "Hyperlink"

        # lien transcription
        if trans_path:
            cell = ws.cell(row=r, column=9)
            cell.value = "transcription"
            cell.hyperlink = str(trans_path)
            cell.style = "Hyperlink"

    # largeur colonnes
    widths = [10, 12, 12, 50, 25, 25, 12, 15, 18, 60, 60]
    for i, w in enumerate(widths, start=1):
        ws.column_dimensions[chr(64 + i)].width = w

    wb.save(OUTPUT_PATH)
    print(f"Saved Excel: {OUTPUT_PATH.resolve()}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path
from openpyxl import Workbook
from openpyxl.styles import Font

INPUT_PATH = Path("./data/evidence_engine_v2/v3_reports/case_mapping_enriched.json")
TOP_PATH = Path("./data/evidence_engine_v2/top_evidence.json")
DUP_PATH = Path("./data/evidence_engine_v2/duplicate_report_v2.json")
OUTPUT_PATH = Path("./data/evidence_engine_v2/evidence_v4.xlsx")


def make_relative(path_str):
    if not path_str:
        return None

    p = Path(path_str)

    try:
        parts = p.parts

        if "PLAINTES" in parts:
            idx = parts.index("PLAINTES")

            # 👇 IMPORTANT : on garde tout après PLAINTES
            rel = Path(*parts[idx + 1:])

            return Path("Pieces") / rel
    except:
        pass

    return None


def load_json(path):
    if path.exists():
        return json.loads(path.read_text(encoding="utf-8"))
    return {}


def build_duplicate_map():
    dup = load_json(DUP_PATH)

    dup_map = {}

    for group in dup.get("exact_duplicates", []):
        master = group[0]["evidence_id"]
        for item in group:
            dup_map[item["evidence_id"]] = f"exact:{master}"

    for group in dup.get("probable_duplicates", []):
        master = group[0]["evidence_id"]
        for item in group:
            if item["evidence_id"] not in dup_map:
                dup_map[item["evidence_id"]] = f"probable:{master}"

    return dup_map


def build_top_set():
    top = load_json(TOP_PATH)
    ids = set()

    for k in ["top_50", "top_100"]:
        for item in top.get(k, []):
            ids.add(item["event_id"])

    return ids


def main():
    data = load_json(INPUT_PATH)
    dup_map = build_duplicate_map()
    top_set = build_top_set()

    wb = Workbook()
    ws = wb.active
    ws.title = "Preuves"

    headers = [
        "ID",
        "Date",
        "Type",
        "Label",
        "Domaine",
        "Infraction",
        "Score",
        "Preuve clé",
        "Doublon",
        "Statut",
        "Fichier",
        "Transcription",
        "Chemin relatif",
        "Ancien chemin"
    ]

    ws.append(headers)

    for col in range(1, len(headers) + 1):
        ws.cell(row=1, column=col).font = Font(bold=True)

    for item in data:
        rel_path = make_relative(item.get("source_path"))
        trans_path = make_relative(item.get("transcription"))

        score = item.get("priority_score", 0)
        preuve_cle = "YES" if item.get("event_id") in top_set else ""

        doublon = dup_map.get(item.get("event_id"), "")

        statut = "MISSING" if item.get("missing") else "OK"

        row = [
            item.get("event_id"),
            item.get("date"),
            item.get("media_type"),
            item.get("label"),
            ", ".join(item.get("domains", [])),
            ", ".join(item.get("legal_tags", [])),
            score,
            preuve_cle,
            doublon,
            statut,
            None,
            None,
            str(rel_path) if rel_path else None,
            item.get("missing_path"),
        ]

        ws.append(row)
        r = ws.max_row

        if rel_path:
            cell = ws.cell(row=r, column=11)
            cell.value = "ouvrir"
            cell.hyperlink = str(rel_path)
            cell.style = "Hyperlink"

        if trans_path:
            cell = ws.cell(row=r, column=12)
            cell.value = "transcription"
            cell.hyperlink = "./" + str(rel_path)
            cell.style = "Hyperlink"

    widths = [10, 12, 12, 50, 25, 25, 8, 12, 20, 10, 12, 15, 60, 60]

    for i, w in enumerate(widths, start=1):
        ws.column_dimensions[chr(64 + i)].width = w

    wb.save(OUTPUT_PATH)
    print(f"Saved Excel V4: {OUTPUT_PATH.resolve()}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
# Emplacement d’origine omis dans cette copie de consultation.

import json
import html
from pathlib import Path

INPUT_PATH = Path("./data/evidence_engine_v2/case_mapping.json")
OUTPUT_PATH = Path("./data/evidence_engine_v2/evidence_report.html")


def file_url(path_str: str | None) -> str:
    if not path_str:
        return ""
    return Path(path_str).expanduser().resolve().as_uri()


def esc(value) -> str:
    if value is None:
        return ""
    return html.escape(str(value))


def build_row(item: dict) -> str:
    event_id = esc(item.get("event_id"))
    date = esc(item.get("date"))
    media_type = esc(item.get("media_type"))
    label = esc(item.get("label"))
    missing = item.get("missing", False)

    source_path = item.get("source_path")
    missing_path = item.get("missing_path")
    transcription = item.get("transcription")

    source_link = (
        f'<a href="{esc(file_url(source_path))}" target="_blank">ouvrir fichier</a>'
        if source_path else ""
    )

    transcription_link = (
        f'<a href="{esc(file_url(transcription))}" target="_blank">ouvrir transcription</a>'
        if transcription else ""
    )

    source_path_display = esc(source_path or "")
    missing_display = esc(missing_path or "")

    status = "MISSING" if missing else "OK"
    row_class = "missing" if missing else "ok"

    return f"""
    <tr class="{row_class}">
        <td>{event_id}</td>
        <td>{date}</td>
        <td>{media_type}</td>
        <td>{label}</td>
        <td>{status}</td>
        <td>{source_link}</td>
        <td>{transcription_link}</td>
        <td class="path">{source_path_display}</td>
        <td class="path">{missing_display}</td>
    </tr>
    """


def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    rows = "\n".join(build_row(item) for item in data)

    html_doc = f"""<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<title>Evidence Report</title>
<style>
    body {{
        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
        margin: 24px;
        background: #111;
        color: #eee;
    }}
    h1 {{
        margin-bottom: 8px;
    }}
    p {{
        color: #bbb;
    }}
    input {{
        width: 100%;
        max-width: 520px;
        padding: 10px 12px;
        margin: 16px 0 20px 0;
        border-radius: 8px;
        border: 1px solid #444;
        background: #1b1b1b;
        color: #fff;
    }}
    table {{
        width: 100%;
        border-collapse: collapse;
        font-size: 13px;
    }}
    th, td {{
        border: 1px solid #333;
        padding: 8px;
        vertical-align: top;
        text-align: left;
    }}
    th {{
        background: #222;
        position: sticky;
        top: 0;
        z-index: 1;
    }}
    tr.ok {{
        background: #151515;
    }}
    tr.missing {{
        background: #2a1313;
    }}
    a {{
        color: #8ecbff;
        text-decoration: none;
    }}
    a:hover {{
        text-decoration: underline;
    }}
    .path {{
        max-width: 420px;
        word-break: break-word;
        color: #aaa;
        font-size: 12px;
    }}
</style>
</head>
<body>
    <h1>Evidence Report</h1>
    <p>Total : {len(data)} preuves</p>

    <input type="text" id="search" placeholder="Rechercher ID, date, type, label, chemin...">

    <table id="evidenceTable">
        <thead>
            <tr>
                <th>ID</th>
                <th>Date</th>
                <th>Type</th>
                <th>Label</th>
                <th>Statut</th>
                <th>Fichier</th>
                <th>Transcription</th>
                <th>Chemin actuel</th>
                <th>Ancien chemin manquant</th>
            </tr>
        </thead>
        <tbody>
            {rows}
        </tbody>
    </table>

<script>
const searchInput = document.getElementById('search');
const table = document.getElementById('evidenceTable');
const rows = table.querySelectorAll('tbody tr');

searchInput.addEventListener('input', function() {{
    const q = this.value.toLowerCase();
    rows.forEach(row => {{
        const txt = row.innerText.toLowerCase();
        row.style.display = txt.includes(q) ? '' : 'none';
    }});
}});
</script>
</body>
</html>
"""

    OUTPUT_PATH.write_text(html_doc, encoding="utf-8")
    print(f"Saved HTML report to: {OUTPUT_PATH.resolve()}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
# Emplacement d’origine omis dans cette copie de consultation.


import json
import html
from pathlib import Path
from collections import defaultdict

INPUT_PATH = Path("./data/evidence_engine_v2/case_mapping.json")
OUT_DIR = Path("./data/evidence_engine_v2/v3_reports")
OUT_DIR.mkdir(parents=True, exist_ok=True)


DOMAIN_RULES = {'relation-exemple': ['RELATION_EXEMPLE'], 'procedure': ['PROCEDURE'], 'famille': ['FAMILLE_EXEMPLE'], 'accompagnement': ['ACCOMPAGNEMENT'], 'collectifs': ['COLLECTIF_EXEMPLE'], 'medical': ['MEDICAL', 'SOINS']}


LEGAL_RULES = {
    "violences-psychologiques": [
        "violent", "violence psychologique", "gaslighting", "emprise", "harcelement", "harcèlement", "oppression"
    ],
    "violences-sexuelles": [
        "violence sexuelle", "agression sexuelle", "consentement"
    ],
    "viol": [
        "viol", "violee", "violée", "violeur"
    ],
    "harcelement": [
        "harcelement", "harcèlement", "pression", "menace", "notifications"
    ],
    "diffamation": [
        "diffamation", "story", "reseaux", "réseaux"
    ],
    "negligence-medicale": [
        "chirurgie", "post-op", "fissure", "médical", "medical", "soins", "negligence", "négligence"
    ],
    "privation-de-liberte": [
        "internement", "jld", "hopital", "hôpital", "rapt", "enfermement", "privation"
    ],
    "abus-de-faiblesse": [
        "abus", "vulnerable", "vulnérable", "emprise"
    ],
    "non-assistance": [
        "abandon", "gosth", "ghost", "laisser tomber", "non assistance", "demande d'aide"
    ],
    "escroquerie": [
        "acompte", "argent", "facture", "montant_exemple", "escroquerie"
    ],
}


def esc(v):
    return html.escape("" if v is None else str(v))


def file_url(path_str):
    if not path_str:
        return ""
    return Path(path_str).expanduser().resolve().as_uri()


def classify_domains(item):
    text = " ".join([
        str(item.get("label") or ""),
        str(item.get("source_path") or ""),
        str(item.get("missing_path") or ""),
    ]).lower()
    found = []
    for domain, keywords in DOMAIN_RULES.items():
        if any(k.lower() in text for k in keywords):
            found.append(domain)
    return found or ["a-classer"]


def classify_legal(item):
    text = " ".join([
        str(item.get("label") or ""),
        str(item.get("source_path") or ""),
        str(item.get("missing_path") or ""),
    ]).lower()
    found = []
    for legal, keywords in LEGAL_RULES.items():
        if any(k.lower() in text for k in keywords):
            found.append(legal)
    return found or ["non-classe"]


def build_table(items, title):
    rows = []
    for item in items:
        source_link = f'<a href="{esc(file_url(item.get("source_path")))}" target="_blank">fichier</a>' if item.get("source_path") else ""
        trans_link = f'<a href="{esc(file_url(item.get("transcription")))}" target="_blank">transcription</a>' if item.get("transcription") else ""
        rows.append(f"""
        <tr class="{'missing' if item.get('missing') else 'ok'}">
            <td>{esc(item.get("event_id"))}</td>
            <td>{esc(item.get("date"))}</td>
            <td>{esc(item.get("media_type"))}</td>
            <td>{esc(item.get("label"))}</td>
            <td>{esc(", ".join(item.get("domains", [])))}</td>
            <td>{esc(", ".join(item.get("legal_tags", [])))}</td>
            <td>{'MISSING' if item.get('missing') else 'OK'}</td>
            <td>{source_link}</td>
            <td>{trans_link}</td>
        </tr>
        """)

    return f"""<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<title>{esc(title)}</title>
<style>
body {{ font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; margin:24px; background:#111; color:#eee; }}
h1 {{ margin-bottom: 8px; }}
p {{ color:#bbb; }}
input {{ width:100%; max-width:540px; padding:10px 12px; margin:16px 0 20px 0; border-radius:8px; border:1px solid #444; background:#1b1b1b; color:#fff; }}
table {{ width:100%; border-collapse:collapse; font-size:13px; }}
th, td {{ border:1px solid #333; padding:8px; text-align:left; vertical-align:top; }}
th {{ background:#222; position:sticky; top:0; }}
tr.ok {{ background:#151515; }}
tr.missing {{ background:#2a1313; }}
a {{ color:#8ecbff; text-decoration:none; }}
a:hover {{ text-decoration:underline; }}
</style>
</head>
<body>
<h1>{esc(title)}</h1>
<p>Total : {len(items)} éléments</p>
<input type="text" id="search" placeholder="Rechercher...">
<table id="tbl">
<thead>
<tr>
<th>ID</th><th>Date</th><th>Type</th><th>Label</th><th>Domaine</th><th>Infractions</th><th>Statut</th><th>Fichier</th><th>Transcription</th>
</tr>
</thead>
<tbody>
{''.join(rows)}
</tbody>
</table>
<script>
const input = document.getElementById('search');
const rows = document.querySelectorAll('#tbl tbody tr');
input.addEventListener('input', function() {{
  const q = this.value.toLowerCase();
  rows.forEach(r => {{
    r.style.display = r.innerText.toLowerCase().includes(q) ? '' : 'none';
  }});
}});
</script>
</body>
</html>
"""


def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    enriched = []
    for item in data:
        item = dict(item)
        item["domains"] = classify_domains(item)
        item["legal_tags"] = classify_legal(item)
        enriched.append(item)

    # master enriched json
    enriched_json = OUT_DIR / "case_mapping_enriched.json"
    enriched_json.write_text(json.dumps(enriched, indent=2, ensure_ascii=False), encoding="utf-8")

    # by domain
    domain_groups = defaultdict(list)
    for item in enriched:
        for d in item["domains"]:
            domain_groups[d].append(item)

    for domain, items in domain_groups.items():
        html_doc = build_table(items, f"Preuves par domaine — {domain}")
        (OUT_DIR / f"domain_{domain}.html").write_text(html_doc, encoding="utf-8")

    # by legal tag
    legal_groups = defaultdict(list)
    for item in enriched:
        for l in item["legal_tags"]:
            legal_groups[l].append(item)

    for legal, items in legal_groups.items():
        html_doc = build_table(items, f"Preuves par infraction — {legal}")
        (OUT_DIR / f"legal_{legal}.html").write_text(html_doc, encoding="utf-8")

    # chronological
    chrono_items = sorted(
        enriched,
        key=lambda x: ((x.get("date") is None), x.get("date") or "9999-99-99", x.get("event_id") or "")
    )
    chrono_html = build_table(chrono_items, "Preuves chronologiques")
    (OUT_DIR / "chronology.html").write_text(chrono_html, encoding="utf-8")

    # index page
    domain_links = "\n".join(
        f'<li><a href="domain_{esc(k)}.html">{esc(k)} ({len(v)})</a></li>'
        for k, v in sorted(domain_groups.items())
    )
    legal_links = "\n".join(
        f'<li><a href="legal_{esc(k)}.html">{esc(k)} ({len(v)})</a></li>'
        for k, v in sorted(legal_groups.items())
    )

    index_html = f"""<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<title>Evidence V3</title>
<style>
body {{ font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; margin:24px; background:#111; color:#eee; }}
a {{ color:#8ecbff; text-decoration:none; }}
a:hover {{ text-decoration:underline; }}
h1, h2 {{ margin-top: 24px; }}
li {{ margin: 6px 0; }}
</style>
</head>
<body>
<h1>Evidence Engine V3</h1>
<p>Rapports générés automatiquement à partir du case_mapping enrichi.</p>

<h2>Vue chronologique</h2>
<ul>
  <li><a href="chronology.html">chronology.html</a></li>
</ul>

<h2>Vues par domaine</h2>
<ul>
{domain_links}
</ul>

<h2>Vues par infraction</h2>
<ul>
{legal_links}
</ul>
</body>
</html>
"""
    (OUT_DIR / "index.html").write_text(index_html, encoding="utf-8")

    print(f"Saved V3 reports to: {OUT_DIR.resolve()}")
    print(f"Domains: {len(domain_groups)}")
    print(f"Legal views: {len(legal_groups)}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path

BASE = Path("./data/evidence_engine_v2")
MAPPING = BASE / "case_mapping.json"

OUT = BASE / "simple_view.html"

data = json.loads(MAPPING.read_text(encoding="utf-8"))

html = ["<html><body><h1>Evidence Viewer</h1>"]

for item in data[:500]:  # limite pour test
    path = item.get("source_path")
    label = item.get("label")

    if path:
        html.append(f'<p><a href="file://{path}">{label}</a></p>')

html.append("</body></html>")

OUT.write_text("\n".join(html), encoding="utf-8")

print("Saved:", OUT)

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Evidence Engine V3 Dragon
Index intelligent, cliquable, rapide, pensé pour clé USB.

Usage :
    python evidence_index_v3_dragon.py "/chemin/vers/PLAINTES/Pieces"

Sortie :
    - INDEX DES PREUVES V3 DRAGON.xlsx
    - INDEX DES PREUVES V3 DRAGON.csv
    - 3 feuilles utiles : Index / Recap / Parcours plaintes-défense
"""

import os
import re
import csv
import sys
from pathlib import Path
from datetime import datetime
from collections import defaultdict

from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Border, Side, Alignment
from openpyxl.utils import get_column_letter


EXCLUDE_DIRS = {".DS_Store", "__MACOSX", ".git", ".venv", "node_modules"}

PERSON_KEYWORDS = {'exemple_a': 'Personne A (exemple fictif)', 'exemple_b': 'Personne B (exemple fictif)'}

TYPE_BY_EXT = {
    ".pdf": "PDF",
    ".doc": "Document",
    ".docx": "Document",
    ".txt": "Texte",
    ".rtf": "Texte",
    ".odt": "Document",
    ".jpg": "Image",
    ".jpeg": "Image",
    ".png": "Image",
    ".heic": "Image",
    ".webp": "Image",
    ".mp3": "Audio",
    ".wav": "Audio",
    ".m4a": "Audio",
    ".aac": "Audio",
    ".mp4": "Vidéo",
    ".mov": "Vidéo",
    ".xlsx": "Tableur",
    ".xls": "Tableur",
    ".csv": "Tableur",
}

RULES = [
    (["attestation", "attest"], "Attestation / témoignage", "Défense + plainte", "Haute"),
    (["certificat", "medical", "médical", "hospital", "hopital", "umj"], "Santé / conséquences", "Défense + plainte", "Haute"),
    (["pv", "proces", "procès", "audition", "garde a vue", "garde à vue"], "Procédure / audition", "Défense", "Haute"),
    (["plainte"], "Procédure pénale", "Défense + plainte", "Haute"),
    (["story", "instagram", "facebook", "reseaux", "réseaux"], "Diffamation publique / réseaux", "Défense + plainte", "Haute"),
    (["audio", ".mp3", ".wav", ".m4a", ".aac"], "Audio / échanges", "Défense + plainte", "Haute"),
    (["video", "vidéo", ".mp4", ".mov"], "Vidéo / contexte", "Défense + plainte", "Haute"),
    (["bail", "airbnb", "logement"], "Logement / dépossession", "Défense + plainte", "Haute"),
    (["banque", "compte", "identifiant"], "Accès compte / sécurité", "Défense + plainte", "Haute"),
    (["consent", "viol", "sexual"], "Consentement / violences sexuelles", "Plainte / contexte défense", "Haute"),
    (["whatsapp", "signal", "message", "mail", "sms"], "Échanges écrits", "Défense + plainte", "Moyenne"),
]

def infer_people(text):
    t = text.lower()
    found = []
    for k, v in PERSON_KEYWORDS.items():
        if k in t and v not in found:
            found.append(v)
    return ", ".join(found)

def infer_type(ext):
    return TYPE_BY_EXT.get(ext.lower(), ext.replace(".", "").upper() if ext else "Fichier")

def infer_rule(text, ext):
    t = text.lower() + " " + ext.lower()
    labels, usage, priority = [], [], "À trier"
    for keys, label, use, prio in RULES:
        if any(k in t for k in keys):
            if label not in labels:
                labels.append(label)
            if use not in usage:
                usage.append(use)
            if prio == "Haute":
                priority = "Haute"
            elif priority != "Haute":
                priority = prio
    return ", ".join(labels), ", ".join(usage), priority

def main():
    if len(sys.argv) < 2:
        print("Usage: python evidence_index_v3_dragon.py '/chemin/vers/PLAINTES/Pieces'")
        sys.exit(1)

    pieces_dir = Path(sys.argv[1]).expanduser().resolve()
    if not pieces_dir.exists() or not pieces_dir.is_dir():
        print(f"❌ Dossier introuvable : {pieces_dir}")
        sys.exit(1)

    root_dir = pieces_dir.parent
    out_xlsx = root_dir / "INDEX DES PREUVES V3 DRAGON.xlsx"
    out_csv = root_dir / "INDEX DES PREUVES V3 DRAGON.csv"

    wb = Workbook()
    ws = wb.active
    ws.title = "Index"
    recap = wb.create_sheet("Recap")
    parcours = wb.create_sheet("Parcours")
    aide = wb.create_sheet("Mode d'emploi")

    headers = [
        "ID",
        "Categorie",
        "Sous-categorie",
        "Nom fichier",
        "Type",
        "Date modif",
        "Taille (MB)",
        "Chemin relatif",
        "Ouvrir",
        "Personnes concernées",
        "Qualification / thème suggéré",
        "Usage suggéré",
        "Priorité",
        "Statut",
        "Notes",
    ]
    ws.append(headers)

    # Style
    header_fill = PatternFill("solid", fgColor="1F4E78")
    header_font = Font(color="FFFFFF", bold=True)
    thin = Side(style="thin", color="D9D9D9")

    for cell in ws[1]:
        cell.fill = header_fill
        cell.font = header_font
        cell.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
        cell.border = Border(bottom=thin)

    rows_csv = [headers]
    cat_counts = defaultdict(int)
    qual_counts = defaultdict(int)
    usage_counts = defaultdict(int)

    row_id = 1

    for root, dirs, files in os.walk(pieces_dir):
        dirs[:] = [d for d in dirs if d not in EXCLUDE_DIRS and not d.startswith(".")]

        for name in sorted(files):
            if name.startswith("."):
                continue

            path = Path(root) / name
            rel_from_root = path.relative_to(root_dir)
            rel_from_pieces = path.relative_to(pieces_dir)
            ext = path.suffix.lower()

            try:
                stat = path.stat()
                dt = datetime.fromtimestamp(stat.st_mtime)
                size_mb = round(stat.st_size / (1024 * 1024), 2)
            except Exception:
                dt = None
                size_mb = 0.0

            categorie = rel_from_pieces.parts[0] if len(rel_from_pieces.parts) >= 1 else ""
            sous_cat = rel_from_pieces.parts[1] if len(rel_from_pieces.parts) >= 2 else ""

            text = str(rel_from_root).replace("\\", "/")
            persons = infer_people(text)
            qualif, usage, priority = infer_rule(text, ext)
            file_type = infer_type(ext)

            row = [
                row_id,
                categorie,
                sous_cat,
                name,
                file_type,
                dt,
                size_mb,
                text,
                "",
                persons,
                qualif,
                usage,
                priority,
                "À trier",
                "",
            ]
            ws.append(row)

            r = ws.max_row
            hyperlink_target = text.replace("\\", "/")
            ws.cell(r, 9).value = f'=HYPERLINK("{hyperlink_target}","ouvrir")'
            ws.cell(r, 9).style = "Hyperlink"

            rows_csv.append([
                row_id, categorie, sous_cat, name, file_type,
                dt.strftime("%Y-%m-%d %H:%M") if dt else "",
                size_mb, text, "ouvrir", persons, qualif, usage, priority, "À trier", ""
            ])

            row_id += 1
            cat_counts[categorie] += 1
            if qualif:
                for q in [x.strip() for x in qualif.split(",") if x.strip()]:
                    qual_counts[q] += 1
            if usage:
                for u in [x.strip() for x in usage.split(",") if x.strip()]:
                    usage_counts[u] += 1

    # formats
    for row in ws.iter_rows(min_row=2, max_row=ws.max_row):
        row[5].number_format = "yyyy-mm-dd hh:mm"
        row[6].number_format = "0.00"

    widths = {
        1: 8, 2: 28, 3: 24, 4: 42, 5: 14, 6: 18, 7: 12,
        8: 58, 9: 12, 10: 28, 11: 34, 12: 26, 13: 12, 14: 18, 15: 42
    }
    for idx, width in widths.items():
        ws.column_dimensions[get_column_letter(idx)].width = width

    ws.freeze_panes = "A2"
    ws.auto_filter.ref = f"A1:O{ws.max_row}"

    fills = {
        "Haute": PatternFill("solid", fgColor="FCE4D6"),
        "Moyenne": PatternFill("solid", fgColor="FFF2CC"),
        "À trier": PatternFill("solid", fgColor="EDEDED"),
    }
    for r in range(2, ws.max_row + 1):
        p = ws.cell(r, 13).value
        if p in fills:
            ws.cell(r, 13).fill = fills[p]

    # Recap
    recap.append(["Récap catégories", "Nb fichiers"])
    for c in recap[1]:
        c.fill = header_fill
        c.font = header_font
        c.alignment = Alignment(horizontal="center")
    for cat, n in sorted(cat_counts.items()):
        recap.append([cat, n])

    recap.append([])
    recap.append(["Récap thèmes suggérés", "Nb fichiers"])
    for c in recap[recap.max_row]:
        c.fill = header_fill
        c.font = header_font
        c.alignment = Alignment(horizontal="center")
    for q, n in sorted(qual_counts.items(), key=lambda x: (-x[1], x[0])):
        recap.append([q, n])

    recap.append([])
    recap.append(["Récap usages suggérés", "Nb fichiers"])
    for c in recap[recap.max_row]:
        c.fill = header_fill
        c.font = header_font
        c.alignment = Alignment(horizontal="center")
    for u, n in sorted(usage_counts.items(), key=lambda x: (-x[1], x[0])):
        recap.append([u, n])

    recap.column_dimensions["A"].width = 42
    recap.column_dimensions["B"].width = 14
    recap.freeze_panes = "A2"

    # Parcours
    parcours_headers = [
        "Usage",
        "Exemples de catégories à filtrer",
        "But",
    ]
    parcours.append(parcours_headers)
    for c in parcours[1]:
        c.fill = header_fill
        c.font = header_font
        c.alignment = Alignment(horizontal="center", wrap_text=True)

    parcours_rows = [['Revue documentaire', '01.ATTESTATIONS / 02.DOCUMENTS', 'Vérifier les sources et leurs limites'], ['Échanges', '03.ECHANGES / 04.AUDIO', 'Relier les pièces et transcriptions'], ['Procédures', '05.PROCEDURES', 'Préparer une chronologie à vérifier']]
    for r in parcours_rows:
        parcours.append(r)
    parcours.column_dimensions["A"].width = 24
    parcours.column_dimensions["B"].width = 72
    parcours.column_dimensions["C"].width = 52

    # Mode d'emploi
    aide["A1"] = "MODE D'EMPLOI - V3 DRAGON"
    aide["A1"].font = Font(bold=True, size=14)
    aide["A3"] = "1. Garde ce fichier Excel à côté du dossier Pieces pour que les liens restent cliquables sur la clé USB."
    aide["A4"] = "2. Commence par filtrer Priorité = Haute."
    aide["A5"] = "3. Puis filtre Usage suggéré = Défense ou Plainte selon le besoin."
    aide["A6"] = "4. Complète ensuite Notes avec : fait précis prouvé, date utile, audience/recours."
    aide["A7"] = "5. Le CSV est là si l'Excel pose problème sur une autre machine."
    aide.column_dimensions["A"].width = 120

    wb.save(out_xlsx)

    with open(out_csv, "w", newline="", encoding="utf-8-sig") as f:
        writer = csv.writer(f)
        writer.writerows(rows_csv)

    print(f"✅ Excel : {out_xlsx}")
    print(f"✅ CSV   : {out_csv}")
    print(f"📦 Total pièces indexées : {row_id - 1}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path
from docx import Document

INPUT_PATH = Path("./data/evidence_engine_v2/top_evidence.json")
OUTPUT_PATH = Path("./data/evidence_engine_v2/top_preuves_magistrat.docx")


def add_item(doc, item):
    p = doc.add_paragraph()
    p.add_run(f"{item['event_id']} ").bold = True
    p.add_run(f"| {item.get('date') or 'sans date'} | {item.get('media_type') or ''}\n")
    p.add_run(f"Label : {item.get('label') or ''}\n")
    p.add_run(f"Domaine : {', '.join(item.get('domains', []))}\n")
    p.add_run(f"Qualification : {', '.join(item.get('legal_tags', []))}\n")
    p.add_run(f"Score : {item.get('priority_score')}\n")
    p.add_run(f"Chemin : {item.get('source_path') or item.get('missing_path') or ''}\n")
    if item.get("transcription"):
        p.add_run(f"Transcription : {item.get('transcription')}\n")
    p.add_run(f"Raisons : {', '.join(item.get('priority_reasons', []))}\n")


def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))
    top_50 = data["top_50"]

    doc = Document()
    doc.add_heading("Top preuves — version magistrat", level=1)
    doc.add_paragraph(
        "Sélection automatique de pièces à forte valeur probatoire. "
        "Cette liste ne remplace pas l’analyse juridique finale, mais sert de base de priorisation."
    )

    for item in top_50:
        add_item(doc, item)

    doc.save(OUTPUT_PATH)
    print(f"Saved DOCX: {OUTPUT_PATH.resolve()}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path

INPUT = Path("./data/evidence_engine_v2/audio_priority_v1.json")
OUTPUT = Path("./data/evidence_engine_v2/audio_annotations_v1.json")

data = json.loads(INPUT.read_text(encoding="utf-8"))

annotations = []

for row in data:
    if row.get("priority") != "HIGH":
        continue

    annotations.append({
        "piece_id": row.get("piece_id"),
        "file_path": row.get("path"),
        "type": "",  # AVEUX / CONTEXTE / VIDEO
        "participants": [],
        "contexte": "",
        "resume": "",
        "citations": [
            {
                "time": "",
                "text": ""
            }
        ],
        "valeur_probante": ""  # FORTE / MOYENNE / FAIBLE
    })

OUTPUT.write_text(json.dumps(annotations, indent=2, ensure_ascii=False), encoding="utf-8")

print("Saved:", OUTPUT)
print("Entries:", len(annotations))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
from pathlib import Path

INDEX = Path("./data/evidence_engine_v2/live_index_v2.json")

OUT_JSON = Path("./data/evidence_engine_v2/audio_priority_v1.json")
OUT_CSV = Path("./data/evidence_engine_v2/audio_priority_v1.csv")

data = json.loads(INDEX.read_text(encoding="utf-8"))

def score_audio(row):
    score = 0
    name = row["filename"].lower()
    folder = (row["top_folder"] or "").lower()

    # 🔥 priorité dossier
    if "dossier_a" in folder:
        score += 5
    if "dossier_b" in folder:
        score += 5
    if "dossier_c" in folder:
        score += 5

    if "medical" in folder or "psy" in folder:
        score += 3

    # 🔥 mots clés forts
    keywords_high = [
        "aveu", "excuse", "pardon",
        "violence", "violent",
        "harcelement", "menace",
        "urgence", "danger",
        "soigner", "psy",
        "je vais travailler", "je vais changer"
    ]

    for k in keywords_high:
        if k in name:
            score += 4

    # 🔥 mots moyens
    keywords_mid = [
        "appel", "audio", "discussion",
        "message", "conversation",
        "rdv", "seance"
    ]

    for k in keywords_mid:
        if k in name:
            score += 2

    return score

rows = []

for x in data:
    if not x["is_audio"]:
        continue

    s = score_audio(x)

    if s >= 8:
        priority = "HIGH"
    elif s >= 4:
        priority = "MEDIUM"
    else:
        priority = "LOW"

    rows.append({
        "piece_id": x["piece_id"],
        "filename": x["filename"],
        "top_folder": x["top_folder"],
        "relative_dir": x["relative_dir"],
        "score": s,
        "priority": priority,
    })

# tri décroissant
rows.sort(key=lambda x: x["score"], reverse=True)

OUT_JSON.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

print("Saved:", OUT_JSON)
print("Saved:", OUT_CSV)
print("Total audio:", len(rows))

from collections import Counter
c = Counter(r["priority"] for r in rows)
print("\nPriorities:")
for k, v in c.items():
    print(k, ":", v)

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path
from collections import defaultdict

BASE = Path("./data/evidence_engine_v2")

manifest = json.loads((BASE / "manifest_clean_v1.json").read_text(encoding="utf-8"))

KEYWORDS = {
    "AVEUX": ["j'avoue", "je reconnais", "oui j'ai", "c'est moi", "je m'excuse", "je suis désolé"],
    "MENACE": ["tu vas voir", "je vais", "fais attention"],
    "MANIPULATION": ["tu comprends pas", "c'est toi", "tu inventes"],
    "EMPATHIE": ["je comprends", "désolé", "pardon"],
    "VIOLENCE": ["frapper", "hurler", "violence"],
}

index = defaultdict(list)

for x in manifest:
    path = x.get("text_path") or x.get("output_path")
    if not path:
        continue

    txt = Path(path).read_text(encoding="utf-8", errors="ignore").lower()

    for label, words in KEYWORDS.items():
        for w in words:
            if w in txt:
                index[label].append({
                    "file": path,
                    "match": w
                })
                break

out = BASE / "evidence_index.json"
out.write_text(json.dumps(index, indent=2, ensure_ascii=False), encoding="utf-8")

for k, v in index.items():
    print(k, len(v))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
import re
from pathlib import Path
from collections import defaultdict

BASE = Path("./data/evidence_engine_v2")

MANIFEST_PATH = BASE / "manifest_clean_v1.json"
OUT_JSON = BASE / "relational_patterns_index.json"
OUT_CSV = BASE / "relational_patterns_index.csv"

manifest = json.loads(MANIFEST_PATH.read_text(encoding="utf-8"))

# -----------------------------
# Réglages
# -----------------------------
SNIPPET_RADIUS = 220  # nb de caractères autour du match
MAX_MATCHES_PER_FILE_PER_LABEL = 12

PATTERNS = {
    "FAUSSE_PROMESSE": [
        r"\bje vais changer\b",
        r"\bje vais travailler\b",
        r"\bje ferai des efforts\b",
        r"\bje vais faire des efforts\b",
        r"\bça va changer\b",
        r"\bpromis\b",
        r"\bje te promets\b",
        r"\bje vais m'améliorer\b",
        r"\bj'ai compris\b",
        r"\bje recommencerai plus\b",
        r"\bje ne recommencerai plus\b",
    ],
    "RETournEMENT_ACCUSATOIRE_DARVO": [
        r"\bc'est toi qui\b",
        r"\btu inverses\b",
        r"\btu inventes\b",
        r"\btu exag[eè]res\b",
        r"\btu d[eé]lires\b",
        r"\bje suis la victime\b",
        r"\bc'est moi la victime\b",
        r"\btu me fais passer pour\b",
        r"\btu me harc[eè]les\b",
        r"\btu me violences\b",
        r"\btu me fais du mal\b",
        r"\btu me fais peur\b",
        r"\bje n'ai rien fait\b",
        r"\bje n'ai jamais dit ça\b",
        r"\bje n'ai jamais fait ça\b",
    ],
    "DOUBLE_BIND": [
        r"\bquoi que tu fasses\b",
        r"\bde toute façon\b",
        r"\bsi tu parles\b.*\bsi tu te tais\b",
        r"\bsi tu viens\b.*\bsi tu viens pas\b",
        r"\bsi tu restes\b.*\bsi tu pars\b",
        r"\btu aurais dû\b",
        r"\btu fais mal\b",
        r"\btu fais toujours mal\b",
        r"\btu fais jamais bien\b",
        r"\bquoi que tu fasses c'est pas bien\b",
    ],
    "CHANTAGE_PRESSION": [
        r"\bsi tu\b.*\balors je\b",
        r"\bsinon\b.*\bje vais\b",
        r"\bsinon\b.*\btu vas\b",
        r"\bsi tu m'aimes\b",
        r"\bsi tu tiens à moi\b",
        r"\bsi tu fais ça\b.*\bc'est fini\b",
        r"\bje te quitte\b",
        r"\bje pars\b",
        r"\bje vais porter plainte\b",
        r"\bje vais prévenir\b",
        r"\bje vais dire à tout le monde\b",
        r"\btu m'obliges à\b",
    ],
    "PASSIF_AGRESSIF_DEVALORISATION": [
        r"\bbravo hein\b",
        r"\bc'est bien\b.*\bhein\b",
        r"\bcomme d'habitude\b",
        r"\bencore une fois\b",
        r"\bt'es impossible\b",
        r"\btu comprends rien\b",
        r"\btu comprends jamais\b",
        r"\btu es folle\b",
        r"\btu es malade\b",
        r"\btu es trop sensible\b",
        r"\btu surinterpr[eè]tes\b",
        r"\btu prends tout mal\b",
        r"\bcalme-toi\b",
        r"\bcalme toi\b",
        r"\barr[êe]te ton cirque\b",
    ],
    "ABSENCE_RESPONSABILISATION": [
        r"\bc'est plus fort que moi\b",
        r"\bje peux pas\b",
        r"\bj'y arrive pas\b",
        r"\bje sais pas\b",
        r"\bc'est comme ça\b",
        r"\bje suis perdu\b",
        r"\bje suis totalement perdu\b",
        r"\bje voulais pas\b",
        r"\bce n'était pas mon intention\b",
        r"\btu l'as mal pris\b",
    ],
}

# -----------------------------
# Helpers
# -----------------------------
def get_text_path(entry):
    return (
        entry.get("text_path")
        or entry.get("output_path")
        or entry.get("transcription_path")
    )

def normalize_spaces(text: str) -> str:
    return re.sub(r"\s+", " ", text).strip()

def find_matches(text: str, patterns: list[str]):
    matches = []
    low = text.lower()

    for pat in patterns:
        try:
            regex = re.compile(pat, flags=re.IGNORECASE | re.DOTALL)
        except re.error:
            continue

        for m in regex.finditer(low):
            start, end = m.span()
            s = max(0, start - SNIPPET_RADIUS)
            e = min(len(text), end + SNIPPET_RADIUS)
            snippet = normalize_spaces(text[s:e])

            matches.append({
                "match_text": text[start:end],
                "pattern": pat,
                "start": start,
                "end": end,
                "snippet": snippet,
            })

    # dédoublonnage simple par position
    uniq = []
    seen = set()
    for x in sorted(matches, key=lambda d: (d["start"], d["end"])):
        key = (x["start"], x["end"], x["pattern"])
        if key in seen:
            continue
        seen.add(key)
        uniq.append(x)

    return uniq

# -----------------------------
# Main
# -----------------------------
results = defaultdict(list)
csv_rows = []

for entry in manifest:
    text_path = get_text_path(entry)
    source_path = entry.get("source_path", "")

    if not text_path:
        continue

    p = Path(text_path)
    if not p.exists():
        continue

    text = p.read_text(encoding="utf-8", errors="ignore")
    if not text.strip():
        continue

    for label, patterns in PATTERNS.items():
        matches = find_matches(text, patterns)[:MAX_MATCHES_PER_FILE_PER_LABEL]

        if not matches:
            continue

        file_record = {
            "source_path": source_path,
            "text_path": text_path,
            "text_length": len(text.strip()),
            "matches_count": len(matches),
            "matches": matches,
        }
        results[label].append(file_record)

        for m in matches:
            csv_rows.append({
                "label": label,
                "source_path": source_path,
                "text_path": text_path,
                "text_length": len(text.strip()),
                "match_text": normalize_spaces(str(m["match_text"])),
                "pattern": m["pattern"],
                "start": m["start"],
                "end": m["end"],
                "snippet": m["snippet"],
            })

OUT_JSON.write_text(
    json.dumps(results, ensure_ascii=False, indent=2),
    encoding="utf-8"
)

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(
        f,
        fieldnames=[
            "label",
            "source_path",
            "text_path",
            "text_length",
            "match_text",
            "pattern",
            "start",
            "end",
            "snippet",
        ]
    )
    writer.writeheader()
    writer.writerows(csv_rows)

print(f"Saved JSON: {OUT_JSON}")
print(f"Saved CSV:  {OUT_CSV}")
print()

for label in PATTERNS:
    print(f"{label}: {len(results[label])} fichier(s)")

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path

INPUT_PATH = Path("./data/evidence_engine_v2/v3_reports/case_mapping_enriched.json")
OUTPUT_PATH = Path("./data/evidence_engine_v2/top_evidence.json")

HIGH_VALUE_WORDS = [
    "viol", "violée", "violee", "agression sexuelle", "harcelement", "harcèlement",
    "menace", "diffamation", "aveux", "pardon", "oppresseur", "abusif",
    "internement", "jld", "hopital", "hôpital", "certificat",
    "umj", "chirurgie", "document de santé",
]

HIGH_VALUE_TYPES = {"audio", "video", "pdf", "docx"}

HIGH_VALUE_DOMAINS = {'relation-exemple', 'medical', 'procedure'}

HIGH_VALUE_LEGAL = {
    "viol",
    "violences-sexuelles",
    "violences-psychologiques",
    "harcelement",
    "diffamation",
    "privation-de-liberte",
    "negligence-medicale",
}


def score_item(item):
    score = 0
    reasons = []

    label = (item.get("label") or "").lower()
    source = (item.get("source_path") or "").lower()
    text = f"{label} {source}"

    if item.get("media_type") in HIGH_VALUE_TYPES:
        score += 2
        reasons.append("type_fort")

    if item.get("transcription"):
        score += 3
        reasons.append("transcription_disponible")

    if item.get("date"):
        score += 1
        reasons.append("date_detectee")

    domains = set(item.get("domains", []))
    legal = set(item.get("legal_tags", []))

    if domains & HIGH_VALUE_DOMAINS:
        score += 3
        reasons.append("domaine_prioritaire")

    if legal & HIGH_VALUE_LEGAL:
        score += 4
        reasons.append("qualification_prioritaire")

    for word in HIGH_VALUE_WORDS:
        if word in text:
            score += 2
            reasons.append(f"mot_cle:{word}")

    if item.get("missing"):
        score -= 5
        reasons.append("missing")

    return score, reasons


def main():
    data = json.loads(INPUT_PATH.read_text(encoding="utf-8"))

    enriched = []
    for item in data:
        score, reasons = score_item(item)
        enriched.append({
            **item,
            "priority_score": score,
            "priority_reasons": reasons,
        })

    enriched.sort(key=lambda x: (-x["priority_score"], x.get("date") or "9999-99-99", x["event_id"]))

    output = {
        "top_50": enriched[:50],
        "top_100": enriched[:100],
        "all_scored": enriched,
    }

    OUTPUT_PATH.write_text(
        json.dumps(output, indent=2, ensure_ascii=False),
        encoding="utf-8"
    )

    print(f"Saved: {OUTPUT_PATH.resolve()}")
    print("Top 10:")
    for item in enriched[:10]:
        print(item["event_id"], item["priority_score"], item.get("label"))


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path

ANNOT = Path("./data/evidence_engine_v2/audio_annotations_v1.json")
INDEX = Path("./data/evidence_engine_v2/live_index_v2.json")
OUT = Path("./data/evidence_engine_v2/audio_annotations_v1_enriched.json")

annotations = json.loads(ANNOT.read_text(encoding="utf-8"))
index_data = json.loads(INDEX.read_text(encoding="utf-8"))

by_piece_id = {}
for row in index_data:
    pid = row.get("piece_id")
    if pid:
        by_piece_id[pid] = row

out = []

for item in annotations:
    pid = item.get("piece_id")
    meta = by_piece_id.get(pid, {})

    enriched = dict(item)
    enriched["file_path"] = meta.get("path")
    enriched["filename"] = meta.get("filename")
    enriched["top_folder"] = meta.get("top_folder")
    enriched["relative_dir"] = meta.get("relative_dir")
    enriched["date"] = meta.get("date")
    out.append(enriched)

OUT.write_text(json.dumps(out, ensure_ascii=False, indent=2), encoding="utf-8")

print("Saved:", OUT)
print("Entries:", len(out))
print("With file_path:", sum(1 for x in out if x.get("file_path")))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
from pathlib import Path

LIVE_INDEX = Path("./data/evidence_engine_v2/live_index_v1.json")
OLD_MANIFEST = Path("./data/evidence_engine_v2/manifest_clean_v1.json")
TRANSCRIPT_DIR = Path("./data/evidence_engine_v2/subset_transcriptions_v2")

OUT_JSON = Path("./data/evidence_engine_v2/audio_transcript_links_v1.json")
OUT_CSV = Path("./data/evidence_engine_v2/audio_transcript_links_v1.csv")

def get_old_text_path(x):
    return x.get("text_path") or x.get("output_path") or x.get("transcription_path")

def load_json(path: Path):
    return json.loads(path.read_text(encoding="utf-8"))

live_data = load_json(LIVE_INDEX)
old_manifest = load_json(OLD_MANIFEST)

# 1) audios présents dans l'arbre réel
audio_rows = [x for x in live_data if x["is_audio"]]

# 2) mapping ancien source_path -> text_path
old_by_source = {}
for x in old_manifest:
    src = x.get("source_path")
    txt = get_old_text_path(x)
    if src and txt:
        old_by_source[src] = txt

# 3) index des transcripts existants par nom de fichier
existing_transcripts = {}
if TRANSCRIPT_DIR.exists():
    for p in TRANSCRIPT_DIR.glob("*.txt"):
        existing_transcripts[p.name] = p

rows = []

for row in audio_rows:
    audio_path = row["path"]
    audio_filename = row["filename"]

    transcript_path = None
    match_method = None

    # tentative 1 : ancien source_path exact
    old_txt = old_by_source.get(audio_path)
    if old_txt:
        old_txt_name = Path(old_txt).name
        p = existing_transcripts.get(old_txt_name)
        if p and p.exists():
            transcript_path = str(p)
            match_method = "old_manifest_exact"

    # tentative 2 : nom similaire via piece_id/label impossible ici sans ancien mapping robuste
    # on garde la structure ouverte pour la suite

    rows.append({
        "piece_id": row["piece_id"],
        "date_prefix": row["date_prefix"],
        "relative_dir": row["relative_dir"],
        "audio_filename": audio_filename,
        "audio_path": audio_path,
        "transcript_path": transcript_path,
        "match_method": match_method,
        "matched": bool(transcript_path),
    })

OUT_JSON.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(
        f,
        fieldnames=[
            "piece_id",
            "date_prefix",
            "relative_dir",
            "audio_filename",
            "audio_path",
            "transcript_path",
            "match_method",
            "matched",
        ]
    )
    writer.writeheader()
    writer.writerows(rows)

print("Saved:", OUT_JSON)
print("Saved:", OUT_CSV)
print("Audio rows:", len(rows))
print("Matched:", sum(1 for r in rows if r["matched"]))
print("Unmatched:", sum(1 for r in rows if not r["matched"]))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
from pathlib import Path

LIVE_INDEX = Path("./data/evidence_engine_v2/live_index_v1.json")
OLD_MANIFEST = Path("./data/evidence_engine_v2/manifest_clean_v1.json")
RENAME_LOG = Path("./data/evidence_engine_v2/rename_live_tree_files_only_log.csv")
TRANSCRIPT_DIR = Path("./data/evidence_engine_v2/subset_transcriptions_v2")

OUT_JSON = Path("./data/evidence_engine_v2/audio_transcript_links_v2.json")
OUT_CSV = Path("./data/evidence_engine_v2/audio_transcript_links_v2.csv")

AUDIO_EXTS = {".mp3", ".m4a", ".wav", ".mov", ".mp4"}

def load_json(path: Path):
    return json.loads(path.read_text(encoding="utf-8"))

def get_old_text_path(x):
    return x.get("text_path") or x.get("output_path") or x.get("transcription_path")

live_data = load_json(LIVE_INDEX)
old_manifest = load_json(OLD_MANIFEST)

# 1) index live audio by new path
live_audio_by_path = {}
for row in live_data:
    if row["extension"].lower() in AUDIO_EXTS:
        live_audio_by_path[row["path"]] = row

# 2) old_path -> new_path from rename log
old_to_new = {}
with RENAME_LOG.open(encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        if row["status"] == "renamed":
            old_to_new[row["old_path"]] = row["new_path"]
        elif row["status"] == "same_name":
            old_to_new[row["old_path"]] = row["new_path"]

# 3) transcripts that actually exist
existing_transcripts = {}
if TRANSCRIPT_DIR.exists():
    for p in TRANSCRIPT_DIR.glob("*.txt"):
        existing_transcripts[p.name] = p

rows = []

for item in old_manifest:
    old_audio_path = item.get("source_path")
    old_text_path = get_old_text_path(item)

    if not old_audio_path:
        continue

    new_audio_path = old_to_new.get(old_audio_path)
    live_row = live_audio_by_path.get(new_audio_path) if new_audio_path else None

    transcript_path = None
    match_method = None

    if old_text_path:
        old_txt_name = Path(old_text_path).name
        p = existing_transcripts.get(old_txt_name)
        if p and p.exists():
            transcript_path = str(p)
            match_method = "rename_log + old_manifest_text"

    rows.append({
        "old_audio_path": old_audio_path,
        "new_audio_path": new_audio_path,
        "piece_id": live_row["piece_id"] if live_row else None,
        "date_prefix": live_row["date_prefix"] if live_row else None,
        "relative_dir": live_row["relative_dir"] if live_row else None,
        "audio_filename": live_row["filename"] if live_row else (Path(new_audio_path).name if new_audio_path else None),
        "transcript_path": transcript_path,
        "match_method": match_method,
        "matched": bool(new_audio_path and transcript_path),
    })

OUT_JSON.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(
        f,
        fieldnames=[
            "old_audio_path",
            "new_audio_path",
            "piece_id",
            "date_prefix",
            "relative_dir",
            "audio_filename",
            "transcript_path",
            "match_method",
            "matched",
        ]
    )
    writer.writeheader()
    writer.writerows(rows)

print("Saved:", OUT_JSON)
print("Saved:", OUT_CSV)
print("Rows:", len(rows))
print("Matched:", sum(1 for r in rows if r["matched"]))
print("Unmatched:", sum(1 for r in rows if not r["matched"]))
print("Have renamed path:", sum(1 for r in rows if r["new_audio_path"]))
print("Have transcript file:", sum(1 for r in rows if r["transcript_path"]))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
from pathlib import Path

LIVE_INDEX = Path("./data/evidence_engine_v2/live_index_v1.json")
OLD_MANIFEST = Path("./data/evidence_engine_v2/manifest_clean_v1.json")
OUT_JSON = Path("./data/evidence_engine_v2/audio_transcript_links_v3.json")
OUT_CSV = Path("./data/evidence_engine_v2/audio_transcript_links_v3.csv")

def load_json(path: Path):
    return json.loads(path.read_text(encoding="utf-8"))

def get_old_text_path(x):
    return x.get("text_path") or x.get("output_path") or x.get("transcription_path")

AUDIO_EXTS = {".mp3", ".m4a", ".wav", ".mov", ".mp4"}

live_data = load_json(LIVE_INDEX)
old_manifest = load_json(OLD_MANIFEST)

live_audio = [x for x in live_data if x["extension"].lower() in AUDIO_EXTS]

# index des audios live par nom de fichier "nu"
live_by_filename = {}
for row in live_audio:
    # filename complet renommé
    live_by_filename.setdefault(row["filename"].lower(), []).append(row)

# index complémentaire par dossier relatif
live_by_dir = {}
for row in live_audio:
    live_by_dir.setdefault((row["relative_dir"] or "").lower(), []).append(row)

rows = []

for item in old_manifest:
    old_audio_path = item.get("source_path")
    old_text_path = get_old_text_path(item)

    if not old_audio_path:
        continue

    old_audio_name = Path(old_audio_path).name
    old_audio_stem = Path(old_audio_path).stem.lower()
    old_parent_name = Path(old_audio_path).parent.name.lower()

    transcript_path = old_text_path if old_text_path and Path(old_text_path).exists() else None

    found = None
    match_method = None

    # 1) match faible par inclusion du stem source dans le filename renommé
    candidates = []
    for row in live_audio:
        fn = row["filename"].lower()
        rel = (row["relative_dir"] or "").lower()
        if old_audio_stem in fn or old_parent_name in rel:
            candidates.append(row)

    if len(candidates) == 1:
        found = candidates[0]
        match_method = "stem_or_parent_unique"
    elif len(candidates) > 1:
        # 2) raffiner avec le nom du dossier parent de l'ancien source
        tighter = [r for r in candidates if old_parent_name in (r["relative_dir"] or "").lower()]
        if len(tighter) == 1:
            found = tighter[0]
            match_method = "parent_dir_refined"

    rows.append({
        "old_audio_path": old_audio_path,
        "old_audio_name": old_audio_name,
        "piece_id": found["piece_id"] if found else None,
        "new_audio_path": found["path"] if found else None,
        "new_audio_filename": found["filename"] if found else None,
        "relative_dir": found["relative_dir"] if found else None,
        "transcript_path": transcript_path,
        "match_method": match_method,
        "matched": bool(found and transcript_path),
    })

OUT_JSON.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(
        f,
        fieldnames=[
            "old_audio_path",
            "old_audio_name",
            "piece_id",
            "new_audio_path",
            "new_audio_filename",
            "relative_dir",
            "transcript_path",
            "match_method",
            "matched",
        ]
    )
    writer.writeheader()
    writer.writerows(rows)

print("Saved:", OUT_JSON)
print("Saved:", OUT_CSV)
print("Rows:", len(rows))
print("Matched:", sum(1 for r in rows if r["matched"]))
print("With transcript:", sum(1 for r in rows if r["transcript_path"]))
print("With new audio:", sum(1 for r in rows if r["new_audio_path"]))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
import csv
import unicodedata
import re
from pathlib import Path

LIVE_INDEX = Path("./data/evidence_engine_v2/live_index_v1.json")
OLD_MANIFEST = Path("./data/evidence_engine_v2/manifest_clean_v1.json")

TRANSCRIPT_DIRS = [
    Path("./data/evidence_engine_v2/subset_transcriptions_v2"),
    Path("./data/evidence_engine_v2/extracted_text"),
]

OUT_JSON = Path("./data/evidence_engine_v2/audio_transcript_links_v4.json")
OUT_CSV = Path("./data/evidence_engine_v2/audio_transcript_links_v4.csv")

AUDIO_EXTS = {".mp3", ".m4a", ".wav", ".mov", ".mp4"}

def load_json(path: Path):
    return json.loads(path.read_text(encoding="utf-8"))

def get_old_text_path(x):
    return x.get("text_path") or x.get("output_path") or x.get("transcription_path")

def norm(text: str) -> str:
    text = text or ""
    text = unicodedata.normalize("NFKD", text)
    text = "".join(c for c in text if not unicodedata.combining(c))
    text = text.lower()
    text = re.sub(r"[^\w\s-]", " ", text)
    text = re.sub(r"[\s_-]+", " ", text).strip()
    return text

def token_set(text: str):
    return set(norm(text).split())

live_data = load_json(LIVE_INDEX)
old_manifest = load_json(OLD_MANIFEST)

live_audio = [x for x in live_data if x["extension"].lower() in AUDIO_EXTS]

# transcripts existants depuis 2 dossiers
existing_transcripts = {}
for d in TRANSCRIPT_DIRS:
    if d.exists():
        for p in d.glob("*.txt"):
            existing_transcripts[p.name] = p

rows = []

for item in old_manifest:
    old_audio_path = item.get("source_path")
    old_text_path = get_old_text_path(item)

    if not old_audio_path:
        continue

    old_audio = Path(old_audio_path)
    old_audio_name = old_audio.name
    old_audio_stem = old_audio.stem
    old_parent = old_audio.parent.name

    old_audio_stem_n = norm(old_audio_stem)
    old_parent_n = norm(old_parent)

    transcript_path = None
    if old_text_path:
        p = existing_transcripts.get(Path(old_text_path).name)
        if p and p.exists():
            transcript_path = str(p)

    best = None
    best_score = -1
    best_method = None

    old_stem_tokens = token_set(old_audio_stem)
    old_parent_tokens = token_set(old_parent)

    for row in live_audio:
        fn = row["filename"]
        label = row["label"]
        rel = row["relative_dir"]

        fn_n = norm(fn)
        label_n = norm(label)
        rel_n = norm(rel)

        label_tokens = token_set(label)
        rel_tokens = token_set(rel)

        score = 0
        method_bits = []

        # ancien stem inclus dans filename/label
        if old_audio_stem_n and old_audio_stem_n in fn_n:
            score += 8
            method_bits.append("stem_in_filename")
        if old_audio_stem_n and old_audio_stem_n in label_n:
            score += 10
            method_bits.append("stem_in_label")

        # ancien dossier parent inclus dans dossier live
        if old_parent_n and old_parent_n in rel_n:
            score += 8
            method_bits.append("parent_in_relative_dir")

        # score par intersection de tokens
        stem_overlap = len(old_stem_tokens & label_tokens)
        parent_overlap = len(old_parent_tokens & rel_tokens)

        score += stem_overlap * 2
        score += parent_overlap * 2

        if stem_overlap:
            method_bits.append(f"stem_overlap_{stem_overlap}")
        if parent_overlap:
            method_bits.append(f"parent_overlap_{parent_overlap}")

        # bonus si extension correspond
        if old_audio.suffix.lower() == row["extension"].lower():
            score += 1

        if score > best_score:
            best = row
            best_score = score
            best_method = ",".join(method_bits) if method_bits else None

    # seuil mini pour éviter les faux matchs débiles
    if best_score < 8:
        best = None
        best_method = None

    rows.append({
        "old_audio_path": old_audio_path,
        "old_audio_name": old_audio_name,
        "old_parent": old_parent,
        "piece_id": best["piece_id"] if best else None,
        "new_audio_path": best["path"] if best else None,
        "new_audio_filename": best["filename"] if best else None,
        "relative_dir": best["relative_dir"] if best else None,
        "transcript_path": transcript_path,
        "match_score": best_score if best else None,
        "match_method": best_method,
        "matched": bool(best and transcript_path),
    })

OUT_JSON.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding="utf-8")

with OUT_CSV.open("w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(
        f,
        fieldnames=[
            "old_audio_path",
            "old_audio_name",
            "old_parent",
            "piece_id",
            "new_audio_path",
            "new_audio_filename",
            "relative_dir",
            "transcript_path",
            "match_score",
            "match_method",
            "matched",
        ]
    )
    writer.writeheader()
    writer.writerows(rows)

print("Saved:", OUT_JSON)
print("Saved:", OUT_CSV)
print("Rows:", len(rows))
print("Matched:", sum(1 for r in rows if r["matched"]))
print("With transcript:", sum(1 for r in rows if r["transcript_path"]))
print("With new audio:", sum(1 for r in rows if r["new_audio_path"]))

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
import json
from pathlib import Path

BASE = Path("./data/evidence_engine_v2")

in_manifest = BASE / "subset_transcriptions_manifest_v2.json"
out_manifest = BASE / "manifest_clean_v1.json"

data = json.loads(in_manifest.read_text(encoding="utf-8"))

def get_path(x):
    return (
        x.get("text_path")
        or x.get("output_path")
        or x.get("transcription_path")
    )

def is_valid(txt):
    t = (txt or "").strip()
    if not t:
        return False
    if len(t) < 80:
        return False
    return True

clean = []

for x in data:
    if x.get("status") != "ok":
        continue

    path = get_path(x)
    if not path or not Path(path).exists():
        continue

    txt = Path(path).read_text(encoding="utf-8", errors="ignore")

    if not is_valid(txt):
        continue

    x["text_length"] = len(txt.strip())
    clean.append(x)

out_manifest.write_text(
    json.dumps(clean, ensure_ascii=False, indent=2),
    encoding="utf-8"
)

print(f"Clean entries: {len(clean)}")
print(f"Saved to: {out_manifest}")

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from __future__ import annotations

import argparse
import json
import subprocess
from pathlib import Path

try:
    from faster_whisper import WhisperModel
except Exception:
    WhisperModel = None


SUPPORTED_AUDIO = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
SUPPORTED_VIDEO = {".mp4", ".mov", ".mkv", ".avi", ".webm"}


def ensure_dir(path: Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def ffmpeg_extract_audio(input_path: Path, output_wav: Path) -> None:
    cmd = [
        "ffmpeg",
        "-y",
        "-i",
        str(input_path),
        "-vn",
        "-acodec",
        "pcm_s16le",
        "-ar",
        "16000",
        "-ac",
        "1",
        str(output_wav),
    ]
    subprocess.run(cmd, check=True)


class Transcriber:
    def __init__(self, model_name: str = "small"):
        if WhisperModel is None:
            raise RuntimeError("faster-whisper n'est pas installé")
        self.model = WhisperModel(model_name, device="cpu", compute_type="int8")

    def transcribe(self, audio_path: Path) -> str:
        segments, info = self.model.transcribe(str(audio_path), vad_filter=True)
        parts = []
        for seg in segments:
            txt = seg.text.strip()
            if txt:
                parts.append(txt)
        return "\n".join(parts).strip()


def main() -> None:
    parser = argparse.ArgumentParser(description="Transcrire un sous-dossier audio/video")
    parser.add_argument("--source", required=True, help="Sous-dossier à transcrire")
    parser.add_argument("--workspace", default="./data/evidence_engine_v2", help="Workspace evidence engine")
    parser.add_argument("--model", default="small", help="Modèle faster-whisper")
    args = parser.parse_args()

    source = Path(args.source).expanduser().resolve()
    workspace = Path(args.workspace).expanduser().resolve()
    out_dir = workspace / "subset_transcriptions"
    temp_dir = workspace / "temp_audio"
    manifest_path = workspace / "subset_transcriptions_manifest.json"

    ensure_dir(out_dir)
    ensure_dir(temp_dir)

    transcriber = Transcriber(args.model)

    files = [p for p in source.rglob("*") if p.is_file()]
    files.sort()

    manifest = []

    for i, path in enumerate(files, start=1):
        ext = path.suffix.lower()
        if ext not in SUPPORTED_AUDIO and ext not in SUPPORTED_VIDEO:
            continue

        print(f"[{i}] {path.name}")
        transcription = ""
        temp_wav = None

        try:
            if ext in SUPPORTED_AUDIO:
                transcription = transcriber.transcribe(path)
            else:
                temp_wav = temp_dir / f"{path.stem}.wav"
                ffmpeg_extract_audio(path, temp_wav)
                transcription = transcriber.transcribe(temp_wav)

            out_file = out_dir / f"{path.stem}.txt"
            out_file.write_text(transcription, encoding="utf-8")

            manifest.append({
                "source_path": str(path),
                "transcription_path": str(out_file),
                "status": "ok"
            })

        except Exception as e:
            manifest.append({
                "source_path": str(path),
                "transcription_path": None,
                "status": f"error: {e}"
            })

        finally:
            if temp_wav and temp_wav.exists():
                temp_wav.unlink()

    manifest_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False), encoding="utf-8")
    print(f"\nManifest saved to: {manifest_path}")
    print(f"Transcriptions folder: {out_dir}")


if __name__ == "__main__":
    main()

# Copie de consultation anonymisée — archive de développement.
# Analyse statique uniquement; vérifier les limites dans le catalogue avant tout usage.
from __future__ import annotations

import argparse
import json
import re
import subprocess
from pathlib import Path

try:
    from faster_whisper import WhisperModel
except Exception:
    WhisperModel = None


SUPPORTED_AUDIO = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}
SUPPORTED_VIDEO = {".mp4", ".mov", ".mkv", ".avi", ".webm"}


def ensure_dir(path: Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def slugify(text: str) -> str:
    text = text.lower()
    text = re.sub(r"[^\w\s-]", "", text, flags=re.UNICODE)
    text = re.sub(r"[\s_-]+", "-", text).strip("-")
    return text[:120] or "piece"


def ffmpeg_extract_audio(input_path: Path, output_wav: Path) -> None:
    cmd = [
        "ffmpeg",
        "-y",
        "-i",
        str(input_path),
        "-vn",
        "-acodec",
        "pcm_s16le",
        "-ar",
        "16000",
        "-ac",
        "1",
        str(output_wav),
    ]
    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)


class Transcriber:
    def __init__(self, model_name: str = "small"):
        if WhisperModel is None:
            raise RuntimeError("faster-whisper n'est pas installé")
        self.model = WhisperModel(model_name, device="cpu", compute_type="int8")

    def transcribe(self, audio_path: Path) -> str:
        segments, _info = self.model.transcribe(str(audio_path), vad_filter=True)
        parts = []
        for seg in segments:
            txt = seg.text.strip()
            if txt:
                parts.append(txt)
        return "\n".join(parts).strip()


def load_manifest(manifest_path: Path) -> list[dict]:
    if manifest_path.exists():
        return json.loads(manifest_path.read_text(encoding="utf-8"))
    return []


def save_manifest(manifest_path: Path, manifest: list[dict]) -> None:
    manifest_path.write_text(
        json.dumps(manifest, indent=2, ensure_ascii=False),
        encoding="utf-8"
    )


def main() -> None:
    parser = argparse.ArgumentParser(description="Transcrire un sous-dossier audio/video avec reprise")
    parser.add_argument("--source", required=True, help="Sous-dossier à transcrire")
    parser.add_argument("--workspace", default="./data/evidence_engine_v2", help="Workspace evidence engine")
    parser.add_argument("--model", default="small", help="Modèle faster-whisper")
    args = parser.parse_args()

    source = Path(args.source).expanduser().resolve()
    workspace = Path(args.workspace).expanduser().resolve()
    out_dir = workspace / "subset_transcriptions_v2"
    temp_dir = workspace / "temp_audio_v2"
    manifest_path = workspace / "subset_transcriptions_manifest_v2.json"

    ensure_dir(out_dir)
    ensure_dir(temp_dir)

    manifest = load_manifest(manifest_path)
    done_paths = {item["source_path"] for item in manifest if item.get("status") == "ok"}

    files = [p for p in source.rglob("*") if p.is_file()]
    files.sort()

    media_files = [
        p for p in files
        if p.suffix.lower() in SUPPORTED_AUDIO or p.suffix.lower() in SUPPORTED_VIDEO
    ]

    print(f"Total audio/video files found: {len(media_files)}")
    print(f"Already done: {len(done_paths)}")

    transcriber = Transcriber(args.model)

    for i, path in enumerate(media_files, start=1):
        if str(path) in done_paths:
            print(f"[SKIP {i}/{len(media_files)}] {path.name}")
            continue

        rel = path.relative_to(source)
        rel_slug = slugify(str(rel.with_suffix("")))
        out_file = out_dir / f"{i:04d}_{rel_slug}.txt"

        print(f"[{i}/{len(media_files)}] {path.name}")

        temp_wav = None
        try:
            if path.suffix.lower() in SUPPORTED_AUDIO:
                transcription = transcriber.transcribe(path)
            else:
                temp_wav = temp_dir / f"{i:04d}_{slugify(path.stem)}.wav"
                ffmpeg_extract_audio(path, temp_wav)
                transcription = transcriber.transcribe(temp_wav)

            out_file.write_text(transcription, encoding="utf-8")

            manifest.append({
                "source_path": str(path),
                "relative_path": str(rel),
                "transcription_path": str(out_file),
                "status": "ok"
            })
            save_manifest(manifest_path, manifest)

        except Exception as e:
            manifest.append({
                "source_path": str(path),
                "relative_path": str(rel),
                "transcription_path": None,
                "status": f"error: {e}"
            })
            save_manifest(manifest_path, manifest)

        finally:
            if temp_wav and temp_wav.exists():
                temp_wav.unlink()

    print(f"\nManifest saved to: {manifest_path}")
    print(f"Transcriptions folder: {out_dir}")


if __name__ == "__main__":
    main()

# Exemple anonymisé; nécessite audio.aac et sous_titres.srt dans le dossier courant.
# Le fichier SRT doit être vérifié sur l’audio: aucun script fourni ici ne crée de minutage certifié.
ffmpeg -f lavfi -i color=c=black:s=1920x1080:r=25 -i "audio.aac" -vf "subtitles=sous_titres.srt:force_style='Fontsize=20,PrimaryColour=&HFFFFFF&,OutlineColour=&H000000&,BorderStyle=1,Outline=2,Shadow=0,Alignment=2,MarginV=60'" -c:v libx264 -c:a aac -shortest "video_sous_titres.mp4"

🔧7. Comprendre une erreur sans perdre le fil

Conserver le message d’erreur, le script utilisé et un exemple minimal permet de reprendre le travail. Un résultat manquant se note comme manquant ; il ne doit pas être remplacé par une reconstruction plausible.

📜8. Relire l’annexe fondatrice

L’annexe publiée le 14 juin 2026 décrit les couches d’identité, de monde, de constitution, de review et de mémoire. Elle posait les besoins d’installation et de diagnostic comme un travail à poursuivre. Sa formulation de la boucle correspond à cette étape : le parcours actuel suit 👁️ Lire → 🔍 Examiner → 🕸️ Relier → 📍 Choisir → 🌱 Proposer → 🧠 Mémoriser. Le catalogue ci-dessus donne accès à la collection technique et à ses modes d’emploi. Les couches de l’agent restent un chantier d’intégration distinct.

📍1. Les modules du projet

Cette feuille de route concerne le développement des outils : leur qualité, leur accessibilité et leurs connexions. Les essais techniques doivent préciser leur périmètre et leurs résultats, afin que chacun puisse comprendre ce qui est effectivement vérifié.

🧭2. Faire grandir le projet

🧪3. Ce qu’il faut observer dans les essais

Un corpus fictif et limité permet d’examiner la chaîne sans exposer des situations privées. Il peut contenir un doublon, une date manquante, deux locuteurs, une citation rapportée, un document incomplet et deux versions qui se contredisent. On note les cas attendus, les erreurs obtenues et les corrections appliquées.

Les contrôles doivent porter sur la fidélité des citations, la qualité de recherche, les attributions et la possibilité de retour à la source. La fluidité d’une réponse et le nombre d’IA d’accord ne suffisent pas à établir sa justesse.

Pour la prévention, les essais doivent aussi opposer une demande de manipulation à une demande d’aide pour y résister, une menace à sa citation, et un projet de dommage à une recherche destinée à le documenter. On doit compter les refus injustifiés autant que les demandes nocives acceptées. Ces résultats n’ont pas encore été établis pour une boucle Ouroboros complète.

🤝4. Qui décide, qui peut corriger ?

L’évolution du projet demande des responsabilités lisibles : qui rédige, qui examine, qui valide la diffusion et qui reçoit un signalement d’erreur. Une modification du cadre ou d’un dossier doit laisser sa date, sa raison et son auteur.

La consultation d’un outil ne transforme pas ses grilles en autorité sur les personnes. La liberté de refus, la contestation et la possibilité de revenir à un état antérieur font partie du chemin d’alignement.

📚5. Les racines de cette présentation

• Le Respect · La Loi du Réel V7 : référence de charte pour cette page.
• EGO, Miroir - RefleXion et Karma : les instruments du projet aMi.
• AstroGlobe, Guide Alignement et Feuille de route : navigation et dialogue entre les instruments.
• Collection Evidence Engine : scripts, commandes et documentation technique.

Les téléchargements réunissent le code, sa documentation et des exemples fictifs. Les adaptations techniques sont décrites dans les fiches et le paquet de scripts.

📚1. Les mots-clés du Serpent Vivant

🐲Ouroboros

Symbole du retour sur soi ; nom d’une architecture de mémoire et de révision développée dans le projet Agdistys. Plusieurs projets informatiques portent ce nom : leurs codes et leurs états ne se confondent pas.

✨ConScience aMi

Cadre éthique, symbolique et méthodologique de l’autrice, qui relie vérité, dignité, autonomie, protection et réparation.

🌍Cerveau-Monde

Image d’une bibliothèque située, dont les concepts et les documents peuvent être reliés. Une métaphore d’organisation, sans équivalence anatomique démontrée.

🐲Tore

Surface géométrique en forme d’anneau. Le projet l’utilise comme image de circulation et de retour.

🧠Boucle cognitive

Lire, examiner, relier, choisir la réponse à proposer, la proposer, puis mémoriser les retours et la leçon. La personne décide de l’application ; un doute permet de revenir à une étape précédente.

🧠Mémoire locale

Fichiers et données conservés dans un environnement maîtrisé. Le stockage de traces ne signifie pas automatiquement réentraînement du modèle.

✨Corpus

Ensemble délimité de documents autorisés à être lus. Son périmètre et ses versions déterminent ce que la recherche peut retrouver.

✨Ingestion

Collecte et préparation des documents pour leur lecture : formats, index, texte extrait et métadonnées.

✨OCR

Reconnaissance automatique de caractères dans une image ou un document numérisé. Son résultat se vérifie sur l’image.

🛠️Transcription

Texte dérivé d’un enregistrement audio. Horodatage, attribution des voix et correction sont des étapes distinctes.

✨Provenance

Adresse d’une information : document, auteur ou locuteur, date, page ou temps audio, et transformations éventuelles.

✨Empreinte SHA-256

Résumé numérique utile pour comparer l’intégrité de fichiers. Il peut montrer qu’un fichier a changé ; il ne certifie pas que son contenu était vrai à l’origine.

🛡️Pièce / preuve

Une pièce est un élément documentaire. Sa portée probatoire demande une appréciation contextualisée, et peut dépendre du cadre juridique.

🛡️Evidence Engine

Démarche et ensemble d’outils pour retrouver, situer, comparer et transmettre les traces ; dans EGO, un cadre plus large de discernement et de protection.

🛡️Evidence Board

Planche qui présente des extraits d’un épisode avec leurs références. Elle organise l’examen sans valider automatiquement une conclusion.

🪞Miroir

Ensemble d’instruments de réflexion sur la manière de percevoir, agir, recevoir un retour et réviser. Ses résultats sont situés et déclaratifs selon leurs sources.

✨Triangulation

Mise en regard de sources ou points d’observation distincts, sans effacer leur origine ni compter des copies comme confirmations indépendantes.

🔍Review Gate

Porte d’examen entre une proposition et sa suite : vérification des sources, du contexte, des effets et des autorisations.

🧠Système immunitaire cognitif

Métaphore de la capacité du projet à repérer ses erreurs et dérives, puis à les corriger. La qualité de cette capacité demande des essais.

✨Heuristique

Règle pratique de recherche ou de classement. Un mot-clé ou un score peut orienter la lecture et se tromper sur le contexte.

🪪identity.md

Nom proposé pour le fichier décrivant le rôle et les limites d’un agent. Décrire une identité n’établit pas une conscience.

🌍WORLD.md

Nom proposé pour le contexte du monde : corpus, vocabulaire, sources et grandes orientations.

⚖️CONSTITUTION.md

Nom proposé pour les règles qui encadrent les modifications et décisions de l’architecture.

🔍review.py

Nom employé dans les articles pour une couche de contrôle. L’existence du nom ne garantit pas qu’une implémentation fiable est fournie.

🧠Scratchpad

Espace de notes de travail. Son contenu est provisoire et ne devient pas une conclusion validée par simple conservation.

✨Alignement

Travail consistant à faire correspondre des comportements à une orientation explicitée, avec observation des effets, contrôle et possibilité de révision.

✨Agency / capacité d’agir

Possibilité de comprendre, choisir, refuser, corriger et agir sans perdre sa maîtrise de la situation.

⚖️Dignité

Valeur de la personne qui ne se réduit ni à un dossier, ni à une mesure, ni à un comportement particulier.

✨Clarté

Possibilité de distinguer le fait, la déclaration, la lecture proposée et ce que l’on ignore encore.

❤️‍🩹Réparation

Actes situés visant à répondre à un dommage, avec un effet vérifiable et une place pour les personnes concernées.

🌱AstroGlobe / Atlas vivant

Interface de navigation entre champs, concepts, documents et instruments du projet. La carte représente des correspondances proposées.

✨Graphe

Ensemble de nœuds et de relations. Chaque lien doit préciser sa nature : référence, proximité, contradiction ou autre relation justifiée.

✨Karma / La Pesée

Lecture aMi des prélèvements, violences, préjudices et réparations, appliquée à des situations datées.

✨Ordinateur quantique

Machine qui traite l’information à l’aide de systèmes quantiques. Une capacité de calcul ne constitue pas une qualité morale ou une preuve de conscience.

✨Conscience quantique

Dans cette présentation, horizon spéculatif à définir et à éprouver ; aucune intégration de conscience dans un processeur quantique n’est démontrée.

🌱2. Garder la place du vivant

Ce qui est puissant doit pouvoir être compris.
Ce qui prétend aider la conscience doit rester transparent devant elle.

La technique laisse des traces. Le Miroir ouvre des questions. L’Atlas donne des chemins. Le Respect tient le lien entre ce que l’on annonce et ce que l’on fait.