From aed98f17ea97cc4a40885365d011eeddc83a4dc1 Mon Sep 17 00:00:00 2001 From: StillHammer Date: Tue, 23 Dec 2025 07:20:39 +0800 Subject: [PATCH] Update project structure and documentation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Update CLAUDE.md to reflect new directory structure - Add ancien-confluent and proto-confluent language variants - Reorganize ConfluentTranslator with modular architecture - Add comprehensive user guide (GUIDE_UTILISATION.md) - Update API documentation and configuration files - Clean up obsolete documentation files đŸ€– Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 --- CLAUDE.md | 314 ++--- ConfluentTranslator/TEST_RESULTS.md | 205 --- ConfluentTranslator/ancien-confluent | 0 .../data/lexique-francais-confluent.json | 0 ConfluentTranslator/data/lexique.json | 0 ConfluentTranslator/docs/API.md | 1109 +++++++++++++++++ .../docs/changelog/COMMIT_SUMMARY.md | 185 --- .../docs/changelog/TESTS_NOMBRES_RESULTAT.md | 168 --- .../docs/changelog/TESTS_SUMMARY.md | 358 ------ .../changelog/test-results-radical-system.md | 243 ---- .../analysis/ANALYSE_MOTS_PROBLEMATIQUES.md | 241 ---- .../plans/radical-lookup-system.md | 415 ------ ConfluentTranslator/proto-confluent | 0 docs/GUIDE_UTILISATION.md | 228 ++++ docs/PROMPT_CONTEXTUEL_INTELLIGENT.md | 500 -------- docs/PROMPT_FORMULES_RITUELLES.md | 281 ----- docs/RACINES_VERBES_FRANCAIS.md | 395 ------ docs/TRAVAIL_RACINES_FRANCAISES.md | 475 ------- docs/langue/01-PHONOLOGIE.md | 291 +++++ docs/langue/02-MORPHOLOGIE.md | 614 +++++++++ docs/langue/03-GRAMMAIRE.md | 558 +++++++++ docs/langue/04-SYNTAXE.md | 706 +++++++++++ docs/langue/05-VOCABULAIRE.md | 716 +++++++++++ 23 files changed, 4379 insertions(+), 3623 deletions(-) delete mode 100644 ConfluentTranslator/TEST_RESULTS.md mode change 120000 => 100644 ConfluentTranslator/ancien-confluent mode change 120000 => 100644 ConfluentTranslator/data/lexique-francais-confluent.json mode change 120000 => 100644 ConfluentTranslator/data/lexique.json create mode 100644 ConfluentTranslator/docs/API.md delete mode 100644 ConfluentTranslator/docs/changelog/COMMIT_SUMMARY.md delete mode 100644 ConfluentTranslator/docs/changelog/TESTS_NOMBRES_RESULTAT.md delete mode 100644 ConfluentTranslator/docs/changelog/TESTS_SUMMARY.md delete mode 100644 ConfluentTranslator/docs/changelog/test-results-radical-system.md delete mode 100644 ConfluentTranslator/docs/dev/analysis/ANALYSE_MOTS_PROBLEMATIQUES.md delete mode 100644 ConfluentTranslator/plans/radical-lookup-system.md mode change 120000 => 100644 ConfluentTranslator/proto-confluent create mode 100644 docs/GUIDE_UTILISATION.md delete mode 100644 docs/PROMPT_CONTEXTUEL_INTELLIGENT.md delete mode 100644 docs/PROMPT_FORMULES_RITUELLES.md delete mode 100644 docs/RACINES_VERBES_FRANCAIS.md delete mode 100644 docs/TRAVAIL_RACINES_FRANCAISES.md create mode 100644 docs/langue/01-PHONOLOGIE.md create mode 100644 docs/langue/02-MORPHOLOGIE.md create mode 100644 docs/langue/03-GRAMMAIRE.md create mode 100644 docs/langue/04-SYNTAXE.md create mode 100644 docs/langue/05-VOCABULAIRE.md diff --git a/CLAUDE.md b/CLAUDE.md index c79ec42..645680d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,157 +1,157 @@ -# CLAUDE.md - -This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. - -## Projet - -**Confluent** est un projet de crĂ©ation d'une langue construite (conlang) pour la Civilisation de la Confluence, une civilisation fictive du projet de jeu de rĂŽle **civjdr**. - -## État actuel - -Le systĂšme linguistique de base est **validĂ© et documentĂ©** : -- 67 racines (15 sacrĂ©es, 52 standards) -- 16 liaisons sacrĂ©es -- SystĂšme verbal complet (12 verbes, conjugateurs) -- Syntaxe SOV avec particules -- 6 castes et 6 lieux nommĂ©s - -## Structure du projet - -``` -confluent/ -├── CLAUDE.md # Ce fichier -├── docs/ -│ ├── SYSTEM_PROMPT_LLM.md # Prompt pour contextualiser un LLM -│ ├── LEXIQUE_REFERENCE_CONFLUENCE.md # Vocabulaire Ă  traduire -│ ├── langue/ # Documentation linguistique -│ │ ├── 01-PHONOLOGIE.md # Sons, consonnes, voyelles -│ │ ├── 02-MORPHOLOGIE.md # Racines, liaisons sacrĂ©es -│ │ ├── 03-GRAMMAIRE.md # Verbes, conjugaisons, particules -│ │ ├── 04-SYNTAXE.md # Structure de phrase, nĂ©gation, questions -│ │ └── 05-VOCABULAIRE.md # Lexique validĂ© (castes, lieux) -│ ├── culture/ -│ │ └── CONTEXTE_CIVILISATION.md # Contexte culturel -│ └── archive/ -│ └── PLAN_LANGUE_REGARD_LIBRE.md # Document de travail original -└── data/ - └── lexique.json # DonnĂ©es structurĂ©es (racines, liaisons) -``` - -## Documents de rĂ©fĂ©rence - -### Pour comprendre la langue -1. `docs/langue/01-PHONOLOGIE.md` - Sons et rĂšgles phonĂ©tiques -2. `docs/langue/02-MORPHOLOGIE.md` - Structure des mots et liaisons -3. `docs/langue/03-GRAMMAIRE.md` - Verbes et conjugaisons -4. `docs/langue/04-SYNTAXE.md` - Construction des phrases -5. `docs/langue/05-VOCABULAIRE.md` - Lexique complet - -### Pour le contexte -- `docs/culture/CONTEXTE_CIVILISATION.md` - Valeurs et culture -- `docs/LEXIQUE_REFERENCE_CONFLUENCE.md` - Vocabulaire Ă  traduire - -### Pour un LLM -- `docs/SYSTEM_PROMPT_LLM.md` - Prompt systĂšme complet - -### DonnĂ©es structurĂ©es -- `data/lexique.json` - Racines, liaisons, particules en JSON - -## RĂšgles linguistiques (rĂ©sumĂ©) - -### PhonĂ©tique et Orthographe -- **Consonnes (10):** b, k, l, m, n, p, s, t, v, z -- **Voyelles actives (5):** a, e, i, o, u -- **Voyelles rĂ©servĂ©es:** y, Ă©, Ăš (expansion future) - -**⚠ IMPORTANT : Pas de majuscules en Confluent** -- Le Confluent n'a PAS de distinction majuscule/minuscule -- Tout le texte Confluent est Ă©crit en MINUSCULES -- Les noms propres, castes, lieux sont TOUS en minuscules : "uraakota", "siliaska", "aliaska" -- Les lexiques JSON stockent tout en minuscules - -### Structure des racines -- Toute racine **finit par CV** (consonne + voyelle) -- **~80% standard** : commence par consonne (ex: sili, toka) -- **~20% sacrĂ©e** : commence par voyelle (ex: aska, ura) - -### Les 16 liaisons sacrĂ©es - -| Base | Liaisons | Domaine | -|------|----------|---------| -| **I** | i, ie, ii, iu | AgentivitĂ© | -| **U** | u, ui | Appartenance | -| **A** | a, aa, ae, ao | Relation | -| **O** | o, oa | Tension | -| **E** | e, ei, ea, eo | Dimension | - -### Composition -``` -sili (regard) + -i- (agent) + aska (libre) -→ sil- + i + aska = Siliaska -``` - -## Vocabulaire validĂ© - -### Castes -| Français | Confluent | -|----------|-----------| -| Enfants des Échos | Nakukeko | -| Enfants du Courant | Nakuura | -| Ailes-Grises | Aliaska | -| Faucons Chasseurs | Akoazana | -| Passes-bien | Takitosa | -| Voix de l'Aurore | Oraumi | - -### Lieux -| Français | Confluent | -|----------|-----------| -| La Confluence | Uraakota | -| Gouffre Humide | Vukuura | -| Antres des Échos | Kekutoka | -| Cercles de Vigile | Sikuvela | -| Halls des Serments | Talusavu | -| Grande Fresque | Ekakova | - -### Peuple -**Siliaska** = "Les porteurs du regard libre" - -## API ConfluentTranslator - -Le serveur de traduction (`ConfluentTranslator/server.js`) expose les endpoints suivants : - -### Gestion des lexiques -- **GET** `/lexique` - Retourne le lexique ancien (legacy) -- **GET** `/api/lexique/:variant` - Retourne le lexique pour `proto` ou `ancien` -- **GET** `/api/stats` - Statistiques des lexiques chargĂ©s -- **POST** `/api/reload` - Recharge les lexiques (dĂ©veloppement) - -### Recherche et analyse -- **GET** `/api/search?q=&variant=&direction=` - Recherche dans le lexique -- **POST** `/api/analyze/coverage` - Analyse la couverture d'un texte français avant traduction - -### Traduction -- **POST** `/translate` - Traduction FR → Confluent avec systĂšme contextuel (retourne layers 1-3) -- **POST** `/api/translate/raw` - Traduction brute sans parsing (debug) -- **POST** `/api/translate/batch` - Traduction par lot de mots -- **POST** `/api/translate/conf2fr` - Traduction Confluent → FR - -### Debug -- **POST** `/api/debug/prompt` - GĂ©nĂšre le prompt systĂšme sans appeler le LLM - -## Prochaines Ă©tapes - -1. Enrichir le lexique (verbes, concepts abstraits, Ă©motions...) -2. DĂ©finir les formules rituelles -3. RĂ©soudre les questions ouvertes (nombres, propositions relatives...) -4. CrĂ©er des outils de traduction/gĂ©nĂ©ration - -## Conventions de travail - -- **Ratio sacrĂ©/standard** : garder ~20-25% de racines sacrĂ©es (V initial) -- **Mix phonĂ©tique** : ~70% crĂ©ations originales, ~20% finnois-like, ~10% basque-like -- **Éviter** : sons trop elfiques (L/R liquides), sons anglo/latins (th, ph) -- **Tester** : chaque nouvelle racine avec des compositions - -## Lien avec civjdr - -Ce projet est un sous-projet de `../civjdr`. La langue reflĂšte les valeurs de la civilisation : observation, transmission, mĂ©moire, confluence/union. +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Projet + +**Confluent** est un projet de crĂ©ation d'une langue construite (conlang) pour la Civilisation de la Confluence, une civilisation fictive du projet de jeu de rĂŽle **civjdr**. + +## État actuel + +Le systĂšme linguistique de base est **validĂ© et documentĂ©** : +- 67 racines (15 sacrĂ©es, 52 standards) +- 16 liaisons sacrĂ©es +- SystĂšme verbal complet (12 verbes, conjugateurs) +- Syntaxe SOV avec particules +- 6 castes et 6 lieux nommĂ©s + +## Structure du projet + +``` +confluent/ +├── CLAUDE.md # Ce fichier +├── docs/ +│ ├── SYSTEM_PROMPT_LLM.md # Prompt pour contextualiser un LLM +│ ├── LEXIQUE_REFERENCE_CONFLUENCE.md # Vocabulaire Ă  traduire +│ ├── langue/ # Documentation linguistique +│ │ ├── 01-PHONOLOGIE.md # Sons, consonnes, voyelles +│ │ ├── 02-MORPHOLOGIE.md # Racines, liaisons sacrĂ©es +│ │ ├── 03-GRAMMAIRE.md # Verbes, conjugaisons, particules +│ │ ├── 04-SYNTAXE.md # Structure de phrase, nĂ©gation, questions +│ │ └── 05-VOCABULAIRE.md # Lexique validĂ© (castes, lieux) +│ ├── culture/ +│ │ └── CONTEXTE_CIVILISATION.md # Contexte culturel +│ └── archive/ +│ └── PLAN_LANGUE_REGARD_LIBRE.md # Document de travail original +└── data/ + └── lexique.json # DonnĂ©es structurĂ©es (racines, liaisons) +``` + +## Documents de rĂ©fĂ©rence + +### Pour comprendre la langue +1. `docs/langue/01-PHONOLOGIE.md` - Sons et rĂšgles phonĂ©tiques +2. `docs/langue/02-MORPHOLOGIE.md` - Structure des mots et liaisons +3. `docs/langue/03-GRAMMAIRE.md` - Verbes et conjugaisons +4. `docs/langue/04-SYNTAXE.md` - Construction des phrases +5. `docs/langue/05-VOCABULAIRE.md` - Lexique complet + +### Pour le contexte +- `docs/culture/CONTEXTE_CIVILISATION.md` - Valeurs et culture +- `docs/LEXIQUE_REFERENCE_CONFLUENCE.md` - Vocabulaire Ă  traduire + +### Pour un LLM +- `docs/SYSTEM_PROMPT_LLM.md` - Prompt systĂšme complet + +### DonnĂ©es structurĂ©es +- `data/lexique.json` - Racines, liaisons, particules en JSON + +## RĂšgles linguistiques (rĂ©sumĂ©) + +### PhonĂ©tique et Orthographe +- **Consonnes (10):** b, k, l, m, n, p, s, t, v, z +- **Voyelles actives (5):** a, e, i, o, u +- **Voyelles rĂ©servĂ©es:** y, Ă©, Ăš (expansion future) + +**⚠ IMPORTANT : Pas de majuscules en Confluent** +- Le Confluent n'a PAS de distinction majuscule/minuscule +- Tout le texte Confluent est Ă©crit en MINUSCULES +- Les noms propres, castes, lieux sont TOUS en minuscules : "uraakota", "siliaska", "aliaska" +- Les lexiques JSON stockent tout en minuscules + +### Structure des racines +- Toute racine **finit par CV** (consonne + voyelle) +- **~80% standard** : commence par consonne (ex: sili, toka) +- **~20% sacrĂ©e** : commence par voyelle (ex: aska, ura) + +### Les 16 liaisons sacrĂ©es + +| Base | Liaisons | Domaine | +|------|----------|---------| +| **I** | i, ie, ii, iu | AgentivitĂ© | +| **U** | u, ui | Appartenance | +| **A** | a, aa, ae, ao | Relation | +| **O** | o, oa | Tension | +| **E** | e, ei, ea, eo | Dimension | + +### Composition +``` +sili (regard) + -i- (agent) + aska (libre) +→ sil- + i + aska = Siliaska +``` + +## Vocabulaire validĂ© + +### Castes +| Français | Confluent | +|----------|-----------| +| Enfants des Échos | Nakukeko | +| Enfants du Courant | Nakuura | +| Ailes-Grises | Aliaska | +| Faucons Chasseurs | Akoazana | +| Passes-bien | Takitosa | +| Voix de l'Aurore | Oraumi | + +### Lieux +| Français | Confluent | +|----------|-----------| +| La Confluence | Uraakota | +| Gouffre Humide | Vukuura | +| Antres des Échos | Kekutoka | +| Cercles de Vigile | Sikuvela | +| Halls des Serments | Talusavu | +| Grande Fresque | Ekakova | + +### Peuple +**Siliaska** = "Les porteurs du regard libre" + +## API ConfluentTranslator + +Le serveur de traduction (`ConfluentTranslator/server.js`) expose les endpoints suivants : + +### Gestion des lexiques +- **GET** `/lexique` - Retourne le lexique ancien (legacy) +- **GET** `/api/lexique/:variant` - Retourne le lexique pour `proto` ou `ancien` +- **GET** `/api/stats` - Statistiques des lexiques chargĂ©s +- **POST** `/api/reload` - Recharge les lexiques (dĂ©veloppement) + +### Recherche et analyse +- **GET** `/api/search?q=&variant=&direction=` - Recherche dans le lexique +- **POST** `/api/analyze/coverage` - Analyse la couverture d'un texte français avant traduction + +### Traduction +- **POST** `/translate` - Traduction FR → Confluent avec systĂšme contextuel (retourne layers 1-3) +- **POST** `/api/translate/raw` - Traduction brute sans parsing (debug) +- **POST** `/api/translate/batch` - Traduction par lot de mots +- **POST** `/api/translate/conf2fr` - Traduction Confluent → FR + +### Debug +- **POST** `/api/debug/prompt` - GĂ©nĂšre le prompt systĂšme sans appeler le LLM + +## Prochaines Ă©tapes + +1. Enrichir le lexique (verbes, concepts abstraits, Ă©motions...) +2. DĂ©finir les formules rituelles +3. RĂ©soudre les questions ouvertes (nombres, propositions relatives...) +4. CrĂ©er des outils de traduction/gĂ©nĂ©ration + +## Conventions de travail + +- **Ratio sacrĂ©/standard** : garder ~20-25% de racines sacrĂ©es (V initial) +- **Mix phonĂ©tique** : ~70% crĂ©ations originales, ~20% finnois-like, ~10% basque-like +- **Éviter** : sons trop elfiques (L/R liquides), sons anglo/latins (th, ph) +- **Tester** : chaque nouvelle racine avec des compositions + +## Lien avec civjdr + +Ce projet est un sous-projet de `../civjdr`. La langue reflĂšte les valeurs de la civilisation : observation, transmission, mĂ©moire, confluence/union. diff --git a/ConfluentTranslator/TEST_RESULTS.md b/ConfluentTranslator/TEST_RESULTS.md deleted file mode 100644 index 0502292..0000000 --- a/ConfluentTranslator/TEST_RESULTS.md +++ /dev/null @@ -1,205 +0,0 @@ -# Tests des Endpoints - ConfluentTranslator API - -**Date:** 2025-12-04 -**Statut:** ✅ TOUS LES ENDPOINTS FONCTIONNELS - ---- - -## RĂ©sumĂ© - -- ✅ **Serveur:** Running (PM2) -- ✅ **Lexique:** ChargĂ© (1835 entrĂ©es ancien, 164 proto) -- ✅ **API Keys:** Fonctionnelles -- ✅ **LLM:** Anthropic + OpenAI opĂ©rationnels - ---- - -## Endpoints Publics - -### GET /api/health -```bash -curl http://localhost:3000/api/health -``` -**RĂ©sultat:** ✅ `{"status":"ok"}` - ---- - -## Endpoints AuthentifiĂ©s - -**ClĂ© API Admin:** `d9be0765-c454-47e9-883c-bcd93dd19eae` - -### GET /api/validate -```bash -curl -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - http://localhost:3000/api/validate -``` -**RĂ©sultat:** ✅ `{"valid":true,"user":"Admin","role":"admin"}` - -### GET /api/stats -```bash -curl -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - http://localhost:3000/api/stats -``` -**RĂ©sultat:** ✅ 904 mots Confluent, 1835 mots FR, 670 racines - -### GET /api/search -```bash -curl -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - "http://localhost:3000/api/search?q=enfant&variant=ancien&direction=fr2conf" -``` -**RĂ©sultat:** ✅ TrouvĂ© "naki" + variantes (Nakukeko, Nakuura...) - -### POST /translate (Anthropic) -```bash -curl -X POST -H "Content-Type: application/json" \ - -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - -d '{"text":"Les enfants observent la Confluence","target":"ancien","provider":"anthropic","model":"claude-sonnet-4-20250514"}' \ - http://localhost:3000/translate -``` -**RĂ©sultat:** ✅ `va naki su vo uraakota milak u` -**Tokens Ă©conomisĂ©s:** 23,990 tokens - -### POST /translate (OpenAI) -```bash -curl -X POST -H "Content-Type: application/json" \ - -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - -d '{"text":"bonjour","target":"ancien","provider":"openai","model":"gpt-4o-mini"}' \ - http://localhost:3000/translate -``` -**RĂ©sultat:** ✅ Traduction gĂ©nĂ©rĂ©e - -### POST /api/translate/batch -```bash -curl -X POST -H "Content-Type: application/json" \ - -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - -d '{"words":["enfant","eau","regard"],"target":"ancien"}' \ - http://localhost:3000/api/translate/batch -``` -**RĂ©sultat:** ✅ `{"enfant":"naki","eau":"ura","regard":"spima"}` - -### POST /api/translate/conf2fr -```bash -curl -X POST -H "Content-Type: application/json" \ - -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - -d '{"text":"nakuura","variant":"ancien"}' \ - http://localhost:3000/api/translate/conf2fr -``` -**RĂ©sultat:** ✅ `"enfants du courant"` (100% coverage) - -### POST /api/debug/prompt -```bash -curl -X POST -H "Content-Type: application/json" \ - -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - -d '{"text":"Les enfants observent","target":"ancien"}' \ - http://localhost:3000/api/debug/prompt -``` -**RĂ©sultat:** ✅ Prompt systĂšme complet gĂ©nĂ©rĂ© - -### POST /api/analyze/coverage -```bash -curl -X POST -H "Content-Type: application/json" \ - -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - -d '{"text":"Les enfants observent","target":"ancien"}' \ - http://localhost:3000/api/analyze/coverage -``` -**RĂ©sultat:** ✅ `{"coverage":100,"found":2,"missing":0}` - -### GET /api/llm/limit -```bash -curl -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - http://localhost:3000/api/llm/limit -``` -**RĂ©sultat:** ✅ `{"allowed":true,"remaining":-1,"limit":-1,"used":2}` (Admin = illimitĂ©) - ---- - -## Endpoints Admin - -### GET /api/admin/tokens -```bash -curl -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - http://localhost:3000/api/admin/tokens -``` -**RĂ©sultat:** ✅ Liste de 3 tokens (Admin, TestUser, AutoTest) - -### POST /api/admin/tokens -```bash -curl -X POST -H "Content-Type: application/json" \ - -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - -d '{"name":"NewUser","role":"user"}' \ - http://localhost:3000/api/admin/tokens -``` -**RĂ©sultat:** ✅ Nouveau token crĂ©Ă© avec API key complĂšte retournĂ©e - -### GET /api/admin/stats -```bash -curl -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - http://localhost:3000/api/admin/stats -``` -**RĂ©sultat:** ✅ Stats globales (tokens, logs, requĂȘtes, erreurs) - -### GET /api/admin/logs -```bash -curl -H "X-API-Key: d9be0765-c454-47e9-883c-bcd93dd19eae" \ - "http://localhost:3000/api/admin/logs?limit=5" -``` -**RĂ©sultat:** ✅ 5 derniers logs avec dĂ©tails - ---- - -## Corrections AppliquĂ©es - -### Chemins relatifs corrigĂ©s : -1. ✅ `radicalMatcher.js:5` → `../../../../data/lexique.json` -2. ✅ `morphologicalDecomposer.js:5` → `../../../../data/lexique.json` -3. ✅ `promptBuilder.js:21` → `../../../prompts/` -4. ✅ `auth.js:7,15` → `../../data/` -5. ✅ `server.js:792` → `../../prompts/cf2fr-refinement.txt` - -### Configuration PM2 : -- ✅ CrĂ©Ă© `ecosystem.config.js` -- ✅ PM2 redĂ©marrĂ© avec `--update-env` -- ✅ Variables d'environnement chargĂ©es depuis `.env` -- ✅ PM2 sauvegardĂ© avec `pm2 save` - ---- - -## Performance - -- **Lexique:** 1835 entrĂ©es Ancien-Confluent, 164 Proto-Confluent -- **Économie de tokens:** ~24,000 tokens par traduction (87% d'Ă©conomie) -- **Temps de rĂ©ponse:** ~2s pour traduction LLM -- **MĂ©moire:** ~87 MB - ---- - -## ClĂ©s API Disponibles - -### Admin (illimitĂ©) -``` -d9be0765-c454-47e9-883c-bcd93dd19eae -``` - -### TestUser (20 req/jour) -``` -008d38c2-e6ed-4852-9b8b-a433e197719a -``` - -### AutoTest (20 req/jour) -``` -343c01ae-8e9c-45b4-a04e-98c67d98d889 -``` - ---- - -## Notes Techniques - -- **Providers LLM:** Anthropic (Claude) + OpenAI (GPT) -- **ModĂšles testĂ©s:** `claude-sonnet-4-20250514`, `gpt-4o-mini` -- **Rate limiting:** Admin = illimitĂ©, User = 20 req/jour -- **Logging:** Tous les endpoints loggĂ©s avec dĂ©tails -- **Auth:** BasĂ©e sur API keys (header `X-API-Key`) - ---- - -**Statut Final:** 🎉 TOUS LES ENDPOINTS FONCTIONNENT PARFAITEMENT diff --git a/ConfluentTranslator/ancien-confluent b/ConfluentTranslator/ancien-confluent deleted file mode 120000 index 191d09b..0000000 --- a/ConfluentTranslator/ancien-confluent +++ /dev/null @@ -1 +0,0 @@ -../ancien-confluent \ No newline at end of file diff --git a/ConfluentTranslator/ancien-confluent b/ConfluentTranslator/ancien-confluent new file mode 100644 index 0000000..191d09b --- /dev/null +++ b/ConfluentTranslator/ancien-confluent @@ -0,0 +1 @@ +../ancien-confluent \ No newline at end of file diff --git a/ConfluentTranslator/data/lexique-francais-confluent.json b/ConfluentTranslator/data/lexique-francais-confluent.json deleted file mode 120000 index 57bc02b..0000000 --- a/ConfluentTranslator/data/lexique-francais-confluent.json +++ /dev/null @@ -1 +0,0 @@ -../../data/lexique-francais-confluent.json \ No newline at end of file diff --git a/ConfluentTranslator/data/lexique-francais-confluent.json b/ConfluentTranslator/data/lexique-francais-confluent.json new file mode 100644 index 0000000..57bc02b --- /dev/null +++ b/ConfluentTranslator/data/lexique-francais-confluent.json @@ -0,0 +1 @@ +../../data/lexique-francais-confluent.json \ No newline at end of file diff --git a/ConfluentTranslator/data/lexique.json b/ConfluentTranslator/data/lexique.json deleted file mode 120000 index eb7a41f..0000000 --- a/ConfluentTranslator/data/lexique.json +++ /dev/null @@ -1 +0,0 @@ -../../data/lexique.json \ No newline at end of file diff --git a/ConfluentTranslator/data/lexique.json b/ConfluentTranslator/data/lexique.json new file mode 100644 index 0000000..eb7a41f --- /dev/null +++ b/ConfluentTranslator/data/lexique.json @@ -0,0 +1 @@ +../../data/lexique.json \ No newline at end of file diff --git a/ConfluentTranslator/docs/API.md b/ConfluentTranslator/docs/API.md new file mode 100644 index 0000000..485a823 --- /dev/null +++ b/ConfluentTranslator/docs/API.md @@ -0,0 +1,1109 @@ +# API ConfluentTranslator + +Documentation technique de l'API REST du serveur ConfluentTranslator. + +## Architecture + +- **Framework** : Express.js +- **LLM** : Anthropic Claude / OpenAI GPT +- **Port** : 3000 (configurable via `PORT`) +- **Base URL** : `http://localhost:3000` +- **Authentification** : API key via header `X-API-Key` ou query param `apiKey` + +## Authentification + +Toutes les requĂȘtes (sauf `/api/health`) nĂ©cessitent une API key valide. + +**Header** : +``` +X-API-Key: +``` + +**Query param** : +``` +?apiKey= +``` + +**RĂŽles** : +- `user` : AccĂšs aux endpoints de traduction et consultation +- `admin` : AccĂšs complet incluant gestion des tokens + +## Rate Limiting + +### Endpoints admin +- **Limite** : 50 requĂȘtes / 5 minutes (par IP) +- **Headers** : `X-RateLimit-Limit`, `X-RateLimit-Remaining` + +### Endpoints LLM (traduction) +- **Limite par dĂ©faut** : 20 requĂȘtes / jour (par API key) +- **Admin** : IllimitĂ© +- **Custom keys** : Pas de limite (utilise vos propres clĂ©s LLM) +- **Bypass** : Fournir `customAnthropicKey` ou `customOpenAIKey` dans le body + +## Endpoints publics + +### GET /api/health + +Endpoint de santĂ© du serveur (public, pas d'auth requise). + +**RĂ©ponse** : +```json +{ + "status": "ok", + "timestamp": "2025-12-04T10:30:00.000Z", + "version": "1.0.0" +} +``` + +**Exemple** : +```bash +curl http://localhost:3000/api/health +``` + +--- + +### GET /api/validate + +Valide une API key et retourne les informations utilisateur. + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "valid": true, + "user": "Admin", + "role": "admin" +} +``` + +**Exemple** : +```bash +curl -H "X-API-Key: YOUR_TOKEN" http://localhost:3000/api/validate +``` + +--- + +### GET /api/llm/limit + +VĂ©rifie la limite LLM pour l'API key courante (toujours retourne 200). + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse (autorisĂ©)** : +```json +{ + "allowed": true, + "remaining": 15, + "limit": 20, + "used": 5 +} +``` + +**RĂ©ponse (limite atteinte)** : +```json +{ + "allowed": false, + "error": "Daily LLM request limit reached", + "limit": 20, + "used": 20 +} +``` + +**Exemple** : +```bash +curl -H "X-API-Key: YOUR_TOKEN" http://localhost:3000/api/llm/limit +``` + +--- + +## Gestion des lexiques + +### GET /lexique + +Retourne le lexique ancien-confluent (legacy, pour compatibilitĂ©). + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : Objet JSON du lexique complet + +**Exemple** : +```bash +curl -H "X-API-Key: YOUR_TOKEN" http://localhost:3000/lexique +``` + +--- + +### GET /api/lexique/:variant + +Retourne le lexique pour une variante spĂ©cifique. + +**ParamĂštres** : +- `variant` (path) : `proto` ou `ancien` + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : Objet JSON du lexique + +**Exemple** : +```bash +curl -H "X-API-Key: YOUR_TOKEN" http://localhost:3000/api/lexique/proto +curl -H "X-API-Key: YOUR_TOKEN" http://localhost:3000/api/lexique/ancien +``` + +--- + +### GET /api/stats + +Statistiques du lexique (nombre de racines, compositions, etc.). + +**ParamĂštres** : +- `variant` (query, optionnel) : `proto` ou `ancien` (dĂ©faut: `ancien`) + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "motsCF": 450, + "motsFR": 380, + "totalTraductions": 520, + "racines": 67, + "racinesSacrees": 15, + "racinesStandards": 52, + "compositions": 120, + "verbes": 12, + "verbesIrreguliers": 0, + "particules": 25, + "nomsPropes": 8, + "marqueurs": 15, + "pronoms": 10, + "autres": 5 +} +``` + +**Exemple** : +```bash +curl -H "X-API-Key: YOUR_TOKEN" "http://localhost:3000/api/stats?variant=ancien" +``` + +--- + +### POST /api/reload + +Recharge les lexiques depuis les fichiers JSON (admin seulement). + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "success": true, + "message": "Lexiques reloaded", + "stats": { + "proto": 450, + "ancien": 520 + } +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: ADMIN_TOKEN" http://localhost:3000/api/reload +``` + +--- + +## Recherche et analyse + +### GET /api/search + +Recherche un mot dans le lexique. + +**ParamĂštres** : +- `q` (query, requis) : Mot Ă  rechercher +- `variant` (query, optionnel) : `proto` ou `ancien` (dĂ©faut: `ancien`) +- `direction` (query, optionnel) : `fr2conf` ou `conf2fr` (dĂ©faut: `fr2conf`) + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "query": "regard", + "variant": "ancien", + "direction": "fr2conf", + "results": [ + { + "mot": "regard", + "traductions": [ + { + "confluent": "sili", + "type": "racine", + "contexte": "observation, vision" + } + ] + } + ] +} +``` + +**Exemple** : +```bash +curl -H "X-API-Key: YOUR_TOKEN" "http://localhost:3000/api/search?q=regard&variant=ancien" +curl -H "X-API-Key: YOUR_TOKEN" "http://localhost:3000/api/search?q=sili&direction=conf2fr" +``` + +--- + +### POST /api/analyze/coverage + +Analyse la couverture lexicale d'un texte français avant traduction. + +**Body** : +```json +{ + "text": "Les enfants observent la confluence", + "target": "ancien" +} +``` + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "coverage": 85.5, + "found": [ + { + "word": "enfants", + "confluent": "naku", + "type": "racine", + "score": 1.0 + }, + { + "word": "observer", + "confluent": "sili", + "type": "racine", + "score": 1.0 + } + ], + "missing": [ + { + "word": "la", + "suggestions": [] + } + ], + "stats": { + "totalWords": 5, + "uniqueWords": 5, + "foundCount": 4, + "missingCount": 1, + "entriesUsed": 15, + "useFallback": false + }, + "needsFullRoots": false, + "recommendation": "Good coverage - context only", + "variant": "ancien" +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"text":"Les enfants observent","target":"ancien"}' \ + http://localhost:3000/api/analyze/coverage +``` + +--- + +## Traduction + +### POST /translate + +Endpoint principal de traduction FR → Confluent (avec layers 1-3). + +**Body** : +```json +{ + "text": "Les enfants observent la confluence", + "target": "ancien", + "provider": "anthropic", + "model": "claude-sonnet-4-20250514", + "temperature": 1.0, + "useLexique": true, + "customAnthropicKey": "optional-sk-ant-...", + "customOpenAIKey": "optional-sk-..." +} +``` + +**ParamĂštres** : +- `text` (requis) : Texte français Ă  traduire +- `target` (requis) : `proto` ou `ancien` +- `provider` (requis) : `anthropic` ou `openai` +- `model` (requis) : Nom du modĂšle (ex: `claude-sonnet-4-20250514`, `gpt-4o`) +- `temperature` (optionnel) : 0.0-2.0 (dĂ©faut: 1.0, divisĂ© par 2 pour Claude) +- `useLexique` (optionnel) : Utiliser le systĂšme contextuel (dĂ©faut: true) +- `customAnthropicKey` (optionnel) : ClĂ© API Anthropic personnalisĂ©e (bypass rate limit) +- `customOpenAIKey` (optionnel) : ClĂ© API OpenAI personnalisĂ©e (bypass rate limit) + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "layer1": { + "translation": "naku ve sili uraakota" + }, + "layer2": { + "wordsFound": [ + { + "input": "enfants", + "confluent": "naku", + "type": "racine", + "score": 1.0 + } + ], + "wordsNotFound": ["la"], + "entriesUsed": 15, + "totalLexiqueSize": 520, + "tokensFullLexique": 45000, + "tokensUsed": 8500, + "tokensSaved": 36500, + "savingsPercent": 81.1, + "useFallback": false, + "expansionLevel": 2, + "rootsUsed": 0 + }, + "layer3": { + "analyse": "Phrase simple avec sujet et verbe...", + "strategie": "Utilisation des racines connues...", + "decomposition": "naku (enfants) + ve (marque verbale)...", + "notes": "SOV respectĂ©...", + "wordsCreated": [] + }, + "translation": "naku ve sili uraakota" +} +``` + +**Layers** : +- **Layer 1** : Traduction finale +- **Layer 2** : MĂ©tadonnĂ©es contextuelles (COT cĂŽtĂ© serveur) +- **Layer 3** : Explications LLM (COT cĂŽtĂ© LLM) + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "text":"Les enfants observent la confluence", + "target":"ancien", + "provider":"anthropic", + "model":"claude-sonnet-4-20250514", + "temperature":1.0 + }' \ + http://localhost:3000/translate +``` + +**Avec clĂ© personnalisĂ©e** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "text":"Bonjour", + "target":"ancien", + "provider":"anthropic", + "model":"claude-sonnet-4-20250514", + "customAnthropicKey":"sk-ant-..." + }' \ + http://localhost:3000/translate +``` + +--- + +### POST /api/translate/raw + +Traduction brute sans parsing (debug). + +**Body** : Identique Ă  `/translate` + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "raw_output": "ANALYSE:\nPhrase simple...\n\nConfluent:\nnaku ve sili", + "metadata": { + "wordsFound": [...], + "entriesUsed": 15, + "tokensUsed": 8500 + }, + "length": 245, + "lines": 12 +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "text":"Test", + "target":"ancien", + "provider":"anthropic", + "model":"claude-sonnet-4-20250514" + }' \ + http://localhost:3000/api/translate/raw +``` + +--- + +### POST /api/translate/batch + +Traduction par lot (recherche lexique uniquement, sans LLM). + +**Body** : +```json +{ + "words": ["regard", "libre", "enfant"], + "target": "ancien" +} +``` + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "target": "ancien", + "results": { + "regard": { + "found": true, + "traduction": "sili", + "all_traductions": [ + { + "confluent": "sili", + "type": "racine", + "contexte": "observation" + } + ] + }, + "libre": { + "found": true, + "traduction": "aska", + "all_traductions": [...] + }, + "enfant": { + "found": false + } + } +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"words":["regard","libre"],"target":"ancien"}' \ + http://localhost:3000/api/translate/batch +``` + +--- + +### POST /api/translate/conf2fr + +Traduction Confluent → Français (mot-Ă -mot ou dĂ©taillĂ©e). + +**Body** : +```json +{ + "text": "naku ve sili uraakota", + "variant": "ancien", + "detailed": false +} +``` + +**ParamĂštres** : +- `text` (requis) : Texte en Confluent +- `variant` (optionnel) : `proto` ou `ancien` (dĂ©faut: `ancien`) +- `detailed` (optionnel) : Inclure dĂ©tails morphologiques (dĂ©faut: false) + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse (simple)** : +```json +{ + "translation": "enfants voir confluence", + "coverage": 100, + "wordsTranslated": 3, + "wordsNotTranslated": 0 +} +``` + +**RĂ©ponse (detailed=true)** : +```json +{ + "translation": "enfants voir confluence", + "tokens": [ + { + "confluent": "naku", + "french": "enfants", + "found": true, + "type": "racine" + }, + { + "confluent": "ve", + "french": "voir", + "found": true, + "type": "verbe" + } + ], + "coverage": 100, + "wordsTranslated": 3, + "wordsNotTranslated": 0 +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"text":"naku ve sili","variant":"ancien","detailed":true}' \ + http://localhost:3000/api/translate/conf2fr +``` + +--- + +### POST /api/translate/conf2fr/llm + +Traduction Confluent → Français avec raffinement LLM. + +**Body** : +```json +{ + "text": "naku ve sili uraakota", + "variant": "ancien", + "provider": "anthropic", + "model": "claude-sonnet-4-20250514", + "customAnthropicKey": "optional", + "customOpenAIKey": "optional" +} +``` + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "confluentText": "naku ve sili uraakota", + "rawTranslation": "enfants voir confluence", + "refinedTranslation": "Les enfants observent la Confluence", + "translation": "Les enfants observent la Confluence", + "tokens": [...], + "coverage": 100, + "wordsTranslated": 3, + "wordsNotTranslated": 0, + "provider": "anthropic", + "model": "claude-sonnet-4-20250514" +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "text":"naku ve sili", + "variant":"ancien", + "provider":"anthropic", + "model":"claude-sonnet-4-20250514" + }' \ + http://localhost:3000/api/translate/conf2fr/llm +``` + +--- + +### POST /api/debug/prompt + +GĂ©nĂšre le prompt systĂšme sans appeler le LLM (debug). + +**Body** : +```json +{ + "text": "Les enfants observent", + "target": "ancien", + "useLexique": true +} +``` + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "prompt": "Tu es un traducteur expert...\n\n# CONTEXTE LEXICAL...", + "metadata": { + "wordsFound": [...], + "entriesUsed": 15, + "tokensUsed": 8500, + "tokensSaved": 36500 + }, + "stats": { + "promptLength": 12450, + "promptLines": 280 + } +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"text":"Test","target":"ancien","useLexique":true}' \ + http://localhost:3000/api/debug/prompt +``` + +--- + +## Endpoints admin + +Tous les endpoints admin nĂ©cessitent un token avec `role: "admin"`. + +### POST /api/admin/tokens + +CrĂ©er un nouveau token d'accĂšs. + +**Body** : +```json +{ + "name": "John Doe", + "role": "user" +} +``` + +**ParamĂštres** : +- `name` (requis) : Nom du token +- `role` (optionnel) : `user` ou `admin` (dĂ©faut: `user`) + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "success": true, + "token": { + "id": "uuid-v4", + "name": "John Doe", + "role": "user", + "apiKey": "uuid-v4-full-key", + "createdAt": "2025-12-04T10:30:00.000Z", + "active": true + } +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: ADMIN_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"name":"Alice","role":"user"}' \ + http://localhost:3000/api/admin/tokens +``` + +--- + +### GET /api/admin/tokens + +Liste tous les tokens (clĂ©s masquĂ©es). + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "tokens": [ + { + "id": "admin", + "name": "Admin", + "role": "admin", + "apiKey": "12345678...", + "createdAt": "2025-12-01T00:00:00.000Z", + "active": true, + "lastUsed": "2025-12-04T10:25:00.000Z" + }, + { + "id": "uuid", + "name": "Alice", + "role": "user", + "apiKey": "abcdef12...", + "createdAt": "2025-12-04T10:30:00.000Z", + "active": true + } + ] +} +``` + +**Exemple** : +```bash +curl -H "X-API-Key: ADMIN_TOKEN" http://localhost:3000/api/admin/tokens +``` + +--- + +### POST /api/admin/tokens/:id/disable + +DĂ©sactiver un token. + +**ParamĂštres** : +- `id` (path) : ID du token + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "success": true, + "message": "Token disabled" +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: ADMIN_TOKEN" \ + http://localhost:3000/api/admin/tokens/uuid-123/disable +``` + +--- + +### POST /api/admin/tokens/:id/enable + +RĂ©activer un token. + +**ParamĂštres** : +- `id` (path) : ID du token + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "success": true, + "message": "Token enabled" +} +``` + +**Exemple** : +```bash +curl -X POST -H "X-API-Key: ADMIN_TOKEN" \ + http://localhost:3000/api/admin/tokens/uuid-123/enable +``` + +--- + +### DELETE /api/admin/tokens/:id + +Supprimer un token (sauf admin). + +**ParamĂštres** : +- `id` (path) : ID du token + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "success": true, + "message": "Token deleted" +} +``` + +**Erreur (tentative de suppression admin)** : +```json +{ + "error": "Token not found or cannot be deleted" +} +``` + +**Exemple** : +```bash +curl -X DELETE -H "X-API-Key: ADMIN_TOKEN" \ + http://localhost:3000/api/admin/tokens/uuid-123 +``` + +--- + +### GET /api/admin/stats + +Statistiques globales (tokens et logs). + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "tokens": { + "totalTokens": 5, + "activeTokens": 4 + }, + "logs": { + "totalRequests": 1250, + "successfulRequests": 1180, + "failedRequests": 70, + "avgResponseTime": 245 + } +} +``` + +**Exemple** : +```bash +curl -H "X-API-Key: ADMIN_TOKEN" http://localhost:3000/api/admin/stats +``` + +--- + +### GET /api/admin/logs + +RĂ©cupĂ©rer les logs de requĂȘtes. + +**ParamĂštres** : +- `limit` (query, optionnel) : Nombre de logs (dĂ©faut: 100) +- `user` (query, optionnel) : Filtrer par nom d'utilisateur +- `path` (query, optionnel) : Filtrer par endpoint +- `statusCode` (query, optionnel) : Filtrer par code HTTP + +**Headers requis** : +- `X-API-Key: ` + +**RĂ©ponse** : +```json +{ + "logs": [ + { + "timestamp": "2025-12-04T10:30:00.000Z", + "method": "POST", + "path": "/translate", + "statusCode": 200, + "responseTime": 1250, + "user": "Alice", + "ip": "127.0.0.1" + } + ] +} +``` + +**Exemple** : +```bash +curl -H "X-API-Key: ADMIN_TOKEN" \ + "http://localhost:3000/api/admin/logs?limit=50&user=Alice" +``` + +--- + +## Gestion des erreurs + +### Codes HTTP + +| Code | Signification | Exemple | +|------|---------------|---------| +| 200 | SuccĂšs | Traduction rĂ©ussie | +| 400 | RequĂȘte invalide | ParamĂštre manquant | +| 401 | Non authentifiĂ© | API key manquante ou invalide | +| 403 | Non autorisĂ© | AccĂšs admin requis, token dĂ©sactivĂ© | +| 404 | Non trouvĂ© | Token inexistant | +| 429 | Trop de requĂȘtes | Rate limit dĂ©passĂ© | +| 500 | Erreur serveur | Erreur LLM, lexique non chargĂ© | + +### Format des erreurs + +```json +{ + "error": "Message d'erreur descriptif" +} +``` + +**Erreur rate limit (429)** : +```json +{ + "error": "Daily LLM request limit reached", + "limit": 20, + "used": 20 +} +``` + +**Erreur admin (429)** : +```json +{ + "error": "Too many admin requests." +} +``` + +--- + +## Rate Limiting - Headers + +**Admin endpoints** : +``` +X-RateLimit-Limit: 50 +X-RateLimit-Remaining: 45 +X-RateLimit-Reset: 1701686400 +``` + +**LLM endpoints** : Pas de headers, vĂ©rifier via `/api/llm/limit` + +--- + +## ModĂšles supportĂ©s + +### Anthropic +- `claude-opus-4-20250514` (le plus puissant) +- `claude-sonnet-4-20250514` (recommandĂ© - Ă©quilibrĂ©) +- `claude-haiku-4-20250514` (rapide et Ă©conomique) + +### OpenAI +- `gpt-4o` (recommandĂ©) +- `gpt-4o-mini` (Ă©conomique) +- `gpt-4-turbo` + +--- + +## Exemples complets + +### Workflow complet de traduction + +```bash +# 1. Valider l'API key +curl -H "X-API-Key: YOUR_TOKEN" http://localhost:3000/api/validate + +# 2. Analyser la couverture lexicale +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"text":"Les enfants observent","target":"ancien"}' \ + http://localhost:3000/api/analyze/coverage + +# 3. VĂ©rifier la limite LLM +curl -H "X-API-Key: YOUR_TOKEN" http://localhost:3000/api/llm/limit + +# 4. Traduire +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "text":"Les enfants observent la confluence", + "target":"ancien", + "provider":"anthropic", + "model":"claude-sonnet-4-20250514" + }' \ + http://localhost:3000/translate +``` + +### Traduction avec clĂ© personnalisĂ©e (bypass rate limit) + +```bash +curl -X POST -H "X-API-Key: YOUR_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{ + "text":"Bonjour monde", + "target":"ancien", + "provider":"anthropic", + "model":"claude-sonnet-4-20250514", + "customAnthropicKey":"sk-ant-api03-YOUR-KEY" + }' \ + http://localhost:3000/translate +``` + +### Recherche bidirectionnelle + +```bash +# FR → Confluent +curl -H "X-API-Key: YOUR_TOKEN" \ + "http://localhost:3000/api/search?q=regard&direction=fr2conf" + +# Confluent → FR +curl -H "X-API-Key: YOUR_TOKEN" \ + "http://localhost:3000/api/search?q=sili&direction=conf2fr" +``` + +--- + +## Notes techniques + +### SystĂšme contextuel (useLexique) + +Quand `useLexique: true` (dĂ©faut), le serveur : +1. Analyse le texte français +2. Recherche les mots dans le lexique +3. GĂ©nĂšre un prompt optimisĂ© avec seulement les entrĂ©es pertinentes +4. Économise jusqu'Ă  81% de tokens + +**Expansion levels** : +- `0` : Mots exacts trouvĂ©s +- `1` : + Racines des mots trouvĂ©s +- `2` : + Liaisons sacrĂ©es +- `3` : Fallback (tout le lexique) + +### Parsing de rĂ©ponse LLM + +Le serveur parse automatiquement les sections : +- `ANALYSE:` → `layer3.analyse` +- `STRATÉGIE:` → `layer3.strategie` +- `Confluent:` → `layer1.translation` +- `DĂ©composition:` → `layer3.decomposition` +- `Notes:` → `layer3.notes` + +--- + +## SĂ©curitĂ© + +- **Tokens** : UUID v4 stockĂ©s dans `data/tokens.json` +- **HTTPS** : RecommandĂ© en production +- **CORS** : À configurer selon besoins +- **JWT_SECRET** : Changer en production (`.env`) +- **Admin token** : StockĂ© au premier lancement (console) + +--- + +## DĂ©pannage + +### "API key required" +→ Ajouter header `X-API-Key` ou query param `?apiKey=...` + +### "Token disabled" +→ RĂ©activer via `/api/admin/tokens/:id/enable` + +### "Daily LLM request limit reached" +→ Attendre minuit OU utiliser `customAnthropicKey`/`customOpenAIKey` + +### "Lexique not loaded" +→ VĂ©rifier les fichiers JSON dans `data/` OU appeler `/api/reload` + +### Rate limit admin +→ Attendre 5 minutes OU espacer les requĂȘtes + +--- + +## Support + +Pour plus d'informations : +- **Architecture** : `ConfluentTranslator/STRUCTURE.md` +- **Guide admin** : `ConfluentTranslator/docs/admin/ADMIN_GUIDE.md` +- **SĂ©curitĂ©** : `ConfluentTranslator/docs/security/README_SECURITY.md` diff --git a/ConfluentTranslator/docs/changelog/COMMIT_SUMMARY.md b/ConfluentTranslator/docs/changelog/COMMIT_SUMMARY.md deleted file mode 100644 index 64a516d..0000000 --- a/ConfluentTranslator/docs/changelog/COMMIT_SUMMARY.md +++ /dev/null @@ -1,185 +0,0 @@ -# Commit Summary: Full Lockdown Security - -## 🎯 Objectif -SĂ©curiser TOUS les endpoints de l'API pour empĂȘcher tout accĂšs non authentifiĂ© aux donnĂ©es. - -## 📝 Modifications - -### Fichiers modifiĂ©s -- `server.js` - Ajout `authenticate` middleware sur tous les endpoints -- `public/index.html` - Migration complĂšte vers `authFetch()` avec auto-logout - -### Fichiers crĂ©Ă©s -- `README_SECURITY.md` - Guide rapide de sĂ©curitĂ© -- `SECURITY_TEST.md` - ProcĂ©dure de test dĂ©taillĂ©e -- `CHANGELOG_SECURITY.md` - Documentation complĂšte des changements -- `test-security.sh` - Script de test automatisĂ© -- `COMMIT_SUMMARY.md` - Ce fichier - -## 🔒 Endpoints sĂ©curisĂ©s - -### Avant (partial security) -- ❌ 8 endpoints publics non protĂ©gĂ©s -- ✅ 3 endpoints protĂ©gĂ©s -- ⚠ Endpoint `/api/reload` dangereux et public - -### AprĂšs (full lockdown) -- ✅ 15 endpoints protĂ©gĂ©s -- ✅ 2 endpoints publics volontaires (`/api/health`, page HTML) -- ✅ 100% des donnĂ©es nĂ©cessitent authentification - -## 🎹 Frontend - -### authFetch() amĂ©liorĂ© -- Auto-logout sur 401/403 -- Gestion automatique des sessions expirĂ©es -- Throw error avec message utilisateur clair - -### Login flow -- Test avec `/api/validate` au lieu de `/api/stats` -- Chargement automatique des donnĂ©es aprĂšs connexion -- Meilleure gestion des erreurs - -## 📊 Impact - -### SĂ©curitĂ© -- 🔒 **Niveau de sĂ©curitĂ© : MAXIMAL** -- ✅ Aucune fuite de donnĂ©es possible -- ✅ Rate limiting sur endpoints sensibles -- ✅ Admin routes protĂ©gĂ©es - -### Utilisateur -- ✅ ExpĂ©rience utilisateur amĂ©liorĂ©e -- ✅ Messages d'erreur clairs -- ✅ Auto-logout automatique -- ✅ Pas de changement visuel (UI identique) - -### DĂ©veloppeur -- ✅ Documentation complĂšte -- ✅ Scripts de test fournis -- ✅ Architecture claire et maintenable - -## ✅ Tests - -### Validation effectuĂ©e -- [x] Syntaxe JavaScript valide (`node -c`) -- [x] Tous les `fetch()` remplacĂ©s par `authFetch()` (sauf login) -- [x] Endpoints publics identifiĂ©s et documentĂ©s -- [x] Auto-logout fonctionne sur 401/403 - -### Tests Ă  effectuer (post-dĂ©ploiement) -- [ ] Lancer le serveur (`npm start`) -- [ ] VĂ©rifier crĂ©ation token admin -- [ ] Tester connexion interface web -- [ ] ExĂ©cuter `./test-security.sh` -- [ ] VĂ©rifier tous les endpoints retournent 401 sans auth - -## 📚 Documentation - -### Pour l'utilisateur -- `README_SECURITY.md` - Guide rapide de dĂ©marrage - -### Pour le testeur -- `SECURITY_TEST.md` - ProcĂ©dure de test manuelle -- `test-security.sh` - Script de test automatisĂ© - -### Pour le dĂ©veloppeur -- `CHANGELOG_SECURITY.md` - Historique dĂ©taillĂ© des modifications -- Commentaires inline dans `server.js` (marquĂ©s "SECURED") - -## 🚀 DĂ©ploiement - -### Étapes recommandĂ©es -1. Backup de `data/tokens.json` (si existant) -2. Merge des modifications -3. `npm start` -4. Noter le token admin affichĂ© -5. Tester l'interface web -6. ExĂ©cuter `./test-security.sh` - -### Rollback si problĂšme -```bash -git revert HEAD -npm start -``` - -## 💡 Notes techniques - -### CompatibilitĂ© -- ✅ Backward compatible au niveau code -- ⚠ **BREAKING CHANGE** : Tous les clients doivent s'authentifier -- ⚠ API publique n'existe plus (sauf `/api/health`) - -### Performance -- ✅ Pas d'impact performance (middleware lĂ©ger) -- ✅ LocalStorage pour cache token cĂŽtĂ© client -- ✅ Pas de requĂȘte supplĂ©mentaire par appel API - -### SĂ©curitĂ© -- ✅ Tokens stockĂ©s cĂŽtĂ© serveur uniquement -- ✅ Pas de JWT (pas de dĂ©codage cĂŽtĂ© client) -- ✅ Rate limiting maintenu sur endpoints sensibles -- ✅ CORS non modifiĂ© (mĂȘme origine) - -## ⚠ Breaking Changes - -### Pour les clients existants -**Avant :** Pouvaient appeler `/api/stats`, `/api/lexique/*` sans auth -**AprĂšs :** Doivent fournir header `x-api-key` avec token valide - -### Migration -```javascript -// Ancien code client -fetch('/api/stats') - -// Nouveau code client -fetch('/api/stats', { - headers: { 'x-api-key': 'your-token' } -}) -``` - -## 📈 MĂ©triques - -### Lignes de code -- `server.js` : +20 lignes (nouveaux endpoints publics) -- `server.js` : 9 lignes modifiĂ©es (ajout authenticate) -- `index.html` : +15 lignes (authFetch amĂ©liorĂ©) -- `index.html` : 3 lignes modifiĂ©es (fetch → authFetch) - -### Documentation -- 4 nouveaux fichiers markdown -- 1 script de test bash -- ~800 lignes de documentation totale - -### Tests -- 12 tests automatisĂ©s dans `test-security.sh` -- 10 tests manuels dans `SECURITY_TEST.md` - -## 🎉 RĂ©sultat - -**Mission accomplie !** - -Tous les endpoints sont sĂ©curisĂ©s. L'interface HTML ne peut charger aucune donnĂ©e sans authentification valide. Le systĂšme gĂšre automatiquement les sessions expirĂ©es. - -**Niveau de sĂ©curitĂ© : 🔒 MAXIMAL** - ---- - -## Commande de commit suggĂ©rĂ©e - -```bash -git add ConfluentTranslator/server.js ConfluentTranslator/public/index.html -git add ConfluentTranslator/*.md ConfluentTranslator/*.sh -git commit -m "feat: implement full lockdown security on all endpoints - -- Add authenticate middleware to all API endpoints (except health check) -- Upgrade authFetch() with auto-logout on 401/403 -- Add /api/validate endpoint for token validation -- Secure admin-only endpoints with requireAdmin -- Add comprehensive security documentation and test scripts - -BREAKING CHANGE: All API endpoints now require authentication -Clients must provide x-api-key header with valid token - -Closes #security-full-lockdown" -``` diff --git a/ConfluentTranslator/docs/changelog/TESTS_NOMBRES_RESULTAT.md b/ConfluentTranslator/docs/changelog/TESTS_NOMBRES_RESULTAT.md deleted file mode 100644 index e2d03a1..0000000 --- a/ConfluentTranslator/docs/changelog/TESTS_NOMBRES_RESULTAT.md +++ /dev/null @@ -1,168 +0,0 @@ -# RĂ©sultats des Tests - SystĂšme de Nombres Base 12 - -Date: 2025-11-28 - -## ✅ Tests RĂ©ussis - -### 1. Lexique Nombres (`22-nombres.json`) -- ✅ Fichier crĂ©Ă© et structurĂ© -- ✅ 13 chiffres de base (0-12) -- ✅ Chargement vĂ©rifiĂ©: `tiru` (3), `tolu` (12) -- ✅ Puissances de 12 dĂ©finies (tolusa, toluaa, tolumako) -- ✅ OpĂ©rations arithmĂ©tiques documentĂ©es - -### 2. Prompt SystĂšme (`ancien-system.txt`) -- ✅ Section "SYSTÈME DE NOMBRES (BASE 12)" prĂ©sente -- ✅ Chiffres 0-12 avec vocabulaire Confluent -- ✅ Puissances de 12 documentĂ©es -- ✅ Construction des nombres expliquĂ©e -- ✅ Quantificateurs vagues (tiru tiru, tolu tolu) -- ✅ OpĂ©rations arithmĂ©tiques (samuk, pasak, kisun, toluk) -- ✅ Exemple 4 avec traduction complĂšte de nombres - -### 3. Documentation -- ✅ `SYSTEME_NUMERIQUE_BASE12.md` (600+ lignes) - - Ancrage culturel complet - - 12 lunes, 12 phalanges, 12 clans - - Avantages mathĂ©matiques prouvĂ©s - - Applications pratiques -- ✅ `REFERENCE_RAPIDE_NOMBRES.md` - - Tables de conversion - - Formule de conversion rapide - - Exemples d'usage - -### 4. TODO mis Ă  jour -- ✅ Section "SystĂšme de nombres" marquĂ©e comme FAIT -- ✅ 10 sous-tĂąches complĂ©tĂ©es - -## 📊 État du SystĂšme - -### Fichiers crĂ©Ă©s/modifiĂ©s -``` -ancien-confluent/lexique/22-nombres.json -docs/SYSTEME_NUMERIQUE_BASE12.md -docs/REFERENCE_RAPIDE_NOMBRES.md -ConfluentTranslator/prompts/ancien-system.txt (modifiĂ©) -TODO.md (mis Ă  jour) -``` - -### Contenu validĂ© - -#### Chiffres de base -| Base 10 | Base 12 | Confluent | -|---------|---------|-----------| -| 0 | 0 | zaro | -| 1 | 1 | iko | -| 2 | 2 | diku | -| 3 | 3 | tiru | -| 4 | 4 | katu | -| 5 | 5 | penu | -| 6 | 6 | seku | -| 7 | 7 | sivu | -| 8 | 8 | oktu | -| 9 | 9 | novu | -| 10 | A | deku | -| 11 | B | levu | -| 12 | 10 | tolu | - -#### Puissances de 12 -| Base 10 | Base 12 | Confluent | -|---------|---------|-----------| -| 12 | 10 | tolu | -| 144 | 100 | tolusa | -| 1728 | 1000 | toluaa | -| 20736 | 10000 | tolumako | - -#### Construction des nombres -- Structure: `COEFFICIENT + tolu + UNITÉ` -- Exemple: 25 (base 10) = 21 (base 12) = `diku tolu iko` - -#### Exemples de traduction attendus -``` -Français: Trois enfants. -Confluent: tiru naki - -Français: Douze oiseaux. -Confluent: tolu apo - -Français: Trois enfants voient douze oiseaux. -Confluent: va tiru naki vo tolu apo mirak u -``` - -## ⚠ Tests nĂ©cessitant API Key - -Les tests suivants nĂ©cessitent une clĂ© API Anthropic configurĂ©e: -- `test-simple-nombre.js` - Tests de traduction basiques -- `test-nombres.js` - Suite de tests complĂšte - -Erreur rencontrĂ©e: -``` -Could not resolve authentication method. Expected either apiKey or authToken to be set. -``` - -## 🎯 Tests Manuels RecommandĂ©s - -Pour tester le systĂšme avec l'interface web (http://localhost:3000): - -### Test 1: Nombres simples -1. Phrase: "Trois enfants." -2. Attendu: `tiru naki` - -### Test 2: Nombre sacrĂ© (12) -1. Phrase: "Douze oiseaux volent." -2. Attendu: contient `tolu apo` - -### Test 3: Nombre composĂ© -1. Phrase: "Vingt-cinq guerriers." -2. Attendu: `diku tolu iko` (2×12+1) - -### Test 4: Phrase complĂšte SOV -1. Phrase: "Trois enfants voient douze oiseaux." -2. Attendu: `va tiru naki vo tolu apo mirak u` - -### Test 5: Grosse (144) -1. Phrase: "Une grosse de poissons." -2. Attendu: `tolusa pesa` - -### Test 6: Quantificateur vague -1. Phrase: "Beaucoup d'ancĂȘtres." -2. Attendu: `tolu tolu aita` ou `mako aita` - -### Test 7: Expression idiomatique -1. Phrase: "Je comprends complĂštement." -2. Attendu: `Tolu miraku` (je vois douze) - -## 📝 Notes - -### Avantages de la Base 12 implĂ©mentĂ©s -- ✅ DivisibilitĂ© par 2, 3, 4, 6 -- ✅ Fractions exactes (1/2=0.6, 1/3=0.4, 1/4=0.3) -- ✅ Ancrage culturel (12 lunes, 12 phalanges) -- ✅ Comptage corporel naturel (jusqu'Ă  60) - -### IntĂ©gration culturelle -- ✅ 12 lunaisons du calendrier -- ✅ 12 clans originels (mythologie) -- ✅ Expressions idiomatiques -- ✅ Usage commercial (tolusa = grosse) - -## ✅ Validation Globale - -Le systĂšme de nombres en base 12 est: -- **MathĂ©matiquement cohĂ©rent** ✅ -- **Culturellement ancrĂ©** ✅ -- **Linguistiquement intĂ©grĂ©** ✅ -- **DocumentĂ© complĂštement** ✅ -- **PrĂȘt pour traduction** ✅ - -## 🚀 Prochaines Étapes - -1. ⏳ Tester avec API Key valide -2. ⏳ Valider traductions rĂ©elles avec LLM -3. ⏳ Ajuster si nĂ©cessaire selon rĂ©sultats -4. ⏳ Passer aux Ă©motions (mĂ©taphores corporelles) -5. ⏳ Propositions relatives (BONUS) - ---- - -**SystĂšme de nombres Base 12 - COMPLET et VALIDÉ** ✅ diff --git a/ConfluentTranslator/docs/changelog/TESTS_SUMMARY.md b/ConfluentTranslator/docs/changelog/TESTS_SUMMARY.md deleted file mode 100644 index 00b0737..0000000 --- a/ConfluentTranslator/docs/changelog/TESTS_SUMMARY.md +++ /dev/null @@ -1,358 +0,0 @@ -# đŸ§Ș RĂ©sumĂ© des Tests API - -## ✅ Tests crĂ©Ă©s avec succĂšs ! - -Tous les scripts de test ont Ă©tĂ© crĂ©Ă©s dans le dossier `testsAPI/`. - ---- - -## 📩 Ce qui a Ă©tĂ© crĂ©Ă© - -### Scripts de test (.bat) -1. **test-health.bat** - Test endpoint public (1 test) -2. **test-unauthorized.bat** - Test sĂ©curitĂ© sans auth (13 tests) -3. **test-authorized.bat** - Test accĂšs avec auth (8 tests) -4. **test-all.bat** - Lance tous les tests (22 tests) - -### Scripts utilitaires (.bat) -5. **quick-check.bat** - VĂ©rification rapide (4 checks) -6. **get-token.bat** - Extraction du token admin - -### Documentation (.md) -7. **README.md** - Documentation complĂšte (8 KB) -8. **QUICKSTART.md** - Guide rapide 2 minutes -9. **INDEX.md** - Index et navigation - -**Total : 9 fichiers crĂ©Ă©s** - ---- - -## 🚀 Comment utiliser - -### Option 1 : Tests rapides (2 minutes) - -```cmd -cd ConfluentTranslator\testsAPI - -REM 1. VĂ©rifier que tout est prĂȘt -quick-check.bat - -REM 2. RĂ©cupĂ©rer le token -get-token.bat - -REM 3. Configurer le token dans test-authorized.bat -notepad test-authorized.bat - -REM 4. Lancer tous les tests -test-all.bat -``` - -### Option 2 : Tests individuels - -```cmd -cd ConfluentTranslator\testsAPI - -REM Test endpoint public -test-health.bat - -REM Test sĂ©curitĂ© (sans auth) -test-unauthorized.bat - -REM Test accĂšs (avec auth) -test-authorized.bat -``` - ---- - -## 📊 Couverture des tests - -### Tests automatisĂ©s - -| Script | Endpoints testĂ©s | Tests | DurĂ©e | -|--------|------------------|-------|-------| -| test-health.bat | 1 | 1 | ~2s | -| test-unauthorized.bat | 13 | 13 | ~10s | -| test-authorized.bat | 8 | 8 | ~8s | -| **TOTAL** | **22** | **22** | **~20s** | - -### Endpoints couverts - -**✅ 100% des endpoints sont testĂ©s** - -**GET endpoints (9) :** -- `/api/health` - Public ✅ -- `/api/stats` - ProtĂ©gĂ© ✅ -- `/api/lexique/ancien` - ProtĂ©gĂ© ✅ -- `/api/lexique/proto` - ProtĂ©gĂ© ✅ -- `/api/search` - ProtĂ©gĂ© ✅ -- `/api/validate` - ProtĂ©gĂ© ✅ -- `/lexique` - ProtĂ©gĂ© ✅ - -**POST endpoints (13) :** -- `/translate` - ProtĂ©gĂ© ✅ -- `/api/reload` - Admin only ✅ -- `/api/debug/prompt` - ProtĂ©gĂ© ✅ -- `/api/analyze/coverage` - ProtĂ©gĂ© ✅ -- `/api/translate/raw` - ProtĂ©gĂ© ✅ -- `/api/translate/batch` - ProtĂ©gĂ© ✅ -- `/api/translate/conf2fr` - ProtĂ©gĂ© ✅ -- `/api/translate/conf2fr/llm` - ProtĂ©gĂ© ✅ - ---- - -## 🎯 RĂ©sultats attendus - -### Test rĂ©ussi si : - -**test-health.bat** -``` -[OK] 200 - Endpoint accessible -``` - -**test-unauthorized.bat** -``` -Total: 13 tests -Passes: 13 (401 retourne) -Echoues: 0 - -[OK] Tous les endpoints sont correctement proteges -``` - -**test-authorized.bat** -``` -Total: 8 tests -Passes: 8 (200 OK) -Echoues: 0 - -[OK] Tous les endpoints sont accessibles avec auth -``` - -**test-all.bat** -``` -RESULTATS FINAUX -================ -Total: 22 tests -Passes: 22 -Echoues: 0 - -[OK] Tous les tests sont passes -🔒 Le systeme est correctement securise -``` - ---- - -## 📚 Documentation disponible - -### Dans testsAPI/ -- **QUICKSTART.md** - Guide ultra-rapide (4 Ă©tapes) -- **README.md** - Documentation complĂšte et dĂ©taillĂ©e -- **INDEX.md** - Navigation et organisation - -### Dans le dossier principal -- **README_SECURITY.md** - Guide principal de sĂ©curitĂ© -- **SECURITY_TEST.md** - Tests manuels dĂ©taillĂ©s -- **CHANGELOG_SECURITY.md** - Historique des modifications -- **COMMIT_SUMMARY.md** - RĂ©sumĂ© technique pour commit - ---- - -## 🔧 PrĂ©requis - -### VĂ©rifiĂ©s par quick-check.bat -- ✅ Serveur actif sur port 3000 -- ✅ SĂ©curitĂ© active (401 sans auth) -- ✅ Token admin crĂ©Ă© -- ✅ curl disponible - -### Configuration manuelle -- ⚙ Token configurĂ© dans `test-authorized.bat` - ---- - -## 🐛 DĂ©pannage rapide - -### "Serveur inactif" -```cmd -cd ConfluentTranslator -npm start -``` - -### "Token introuvable" -```cmd -cd ConfluentTranslator -get-token.bat -``` - -### "curl non reconnu" -- Windows 10+ : curl est prĂ©installĂ© -- VĂ©rifier : `curl --version` -- Path : `C:\Windows\System32\curl.exe` - -### "401 avec token valide" -- VĂ©rifier que le token est correct dans `test-authorized.bat` -- VĂ©rifier `data/tokens.json` que `enabled: true` -- Copier le token EXACT (pas d'espace avant/aprĂšs) - ---- - -## 🎹 Formats de sortie - -Les scripts utilisent un format cohĂ©rent : - -``` -======================================== -TEST: Nom du test -======================================== -Expected: RĂ©sultat attendu - -[1] Testing: Description - [OK] Status attendu - ou - [FAIL] Status: XXX (expected YYY) - -======================================== -RESULTATS FINAUX -======================================== -Total: X tests -Passes: Y -Echoues: Z -======================================== -``` - ---- - -## 📈 MĂ©triques - -### Scripts crĂ©Ă©s -- **6 scripts** .bat (4 tests + 2 utilitaires) -- **3 documents** .md (README, QUICKSTART, INDEX) -- **~20 KB** de code et documentation - -### Tests implĂ©mentĂ©s -- **22 tests** automatisĂ©s -- **100%** de couverture endpoints -- **~20 secondes** d'exĂ©cution totale - -### Documentation -- **~15 KB** de documentation -- **3 niveaux** : Quick, Standard, Complet -- **Multilingue** : Français + Anglais (noms fichiers) - ---- - -## ✹ FonctionnalitĂ©s - -### Automatisation -- ✅ Tests parallĂ©lisĂ©s (curl simultanĂ©s) -- ✅ Compteurs automatiques (passed/failed) -- ✅ Codes couleurs (si terminal supportĂ©) -- ✅ Messages d'erreur explicites - -### Robustesse -- ✅ VĂ©rification prĂ©requis -- ✅ Gestion des erreurs -- ✅ Messages clairs -- ✅ Guides de dĂ©pannage - -### FlexibilitĂ© -- ✅ Tests individuels ou groupĂ©s -- ✅ Configuration simple (1 variable) -- ✅ Extension facile (ajouter tests) -- ✅ Documentation exhaustive - ---- - -## 🔗 Workflow complet - -```mermaid -graph TD - A[DĂ©marrer serveur] --> B[quick-check.bat] - B --> C{Tout OK?} - C -->|Non| D[Fix problĂšmes] - D --> B - C -->|Oui| E[get-token.bat] - E --> F[Configurer test-authorized.bat] - F --> G[test-all.bat] - G --> H{Tests OK?} - H -->|Non| I[Debug avec tests individuels] - I --> J[Fix code serveur] - J --> G - H -->|Oui| K[✅ SĂ©curitĂ© validĂ©e] -``` - ---- - -## 🎓 Pour aller plus loin - -### Ajouter un nouveau test - -1. **CrĂ©er le fichier** -```cmd -copy test-health.bat test-custom.bat -notepad test-custom.bat -``` - -2. **Modifier le contenu** -```batch -REM Test: Mon endpoint custom -curl http://localhost:3000/api/custom -``` - -3. **Ajouter dans test-all.bat** -```batch -call test-custom.bat -``` - -4. **Documenter dans README.md** - -### Modifier le serveur de test - -Dans chaque fichier .bat : -```batch -REM Remplacer localhost:3000 par votre serveur -curl http://votre-serveur:port/api/endpoint -``` - -### IntĂ©gration CI/CD - -Les scripts peuvent ĂȘtre appelĂ©s depuis CI/CD : -```yaml -# Example: GitHub Actions -- name: Test API Security - run: | - cd ConfluentTranslator/testsAPI - test-all.bat -``` - ---- - -## 📞 Support - -### ProblĂšme avec les tests ? -1. Lire `testsAPI/README.md` (section DĂ©pannage) -2. VĂ©rifier `quick-check.bat` -3. Consulter `SECURITY_TEST.md` pour tests manuels - -### ProblĂšme avec le serveur ? -1. VĂ©rifier les logs (`npm start`) -2. Consulter `README_SECURITY.md` -3. VĂ©rifier `CHANGELOG_SECURITY.md` - ---- - -## 🎉 C'est prĂȘt ! - -Tous les tests sont crĂ©Ă©s et documentĂ©s. - -**Prochaine Ă©tape :** -```cmd -cd ConfluentTranslator\testsAPI -test-all.bat -``` - -**Bonne chance ! 🚀** - ---- - -**Made with ❀ for ConfluentTranslator** -*Full Lockdown Security Testing Suite v1.0* diff --git a/ConfluentTranslator/docs/changelog/test-results-radical-system.md b/ConfluentTranslator/docs/changelog/test-results-radical-system.md deleted file mode 100644 index fcdf196..0000000 --- a/ConfluentTranslator/docs/changelog/test-results-radical-system.md +++ /dev/null @@ -1,243 +0,0 @@ -# Test du systĂšme de recherche par radicaux - RĂ©sultats - -Date: 2025-11-28 -**DerniĂšre mise Ă  jour:** 2025-11-30 - -## Texte de test (122 tokens) - -``` -Va siluuumi vo mako sekavoki na akoazana vokan at. Va aliaska vo voki aita na aita zo kisun at. No kekutoka tiru okitori vo loku taku su mitak at. Tova vo uraakota na kisiran vokis at. Va umitori velu mirak at. Va alu su vo onuvoki melu su pasun at. Va naki su vo savu su pasun at. Va maku sukamori vo varu mako su zo sukam ul at. Va vokiueka vo kala okimako uravis at. Na tova na uraal kisaran ui vo mako vulu pasak ok se vo talu su vaku nekan ok. Se na kisiran zo urak u suki na velu ve at. Zom na okitori na mako ve at. Se va sekauaita na tori su ui kisun at eol. -``` - -## RĂ©sultats - -### Coverage global -- **Avant implĂ©mentation (plan):** 83% (101/122 tokens) -- **AprĂšs implĂ©mentation et ajout particules:** 94% (115/122 tokens) -- **AmĂ©lioration totale:** +11 points de pourcentage (+14 mots trouvĂ©s) - -### Mots trouvĂ©s (115/122) - -Exemples de mots correctement trouvĂ©s grĂące au systĂšme: -- **Verbes conjuguĂ©s (via radicaux):** - - `vokan`, `vokis` → trouvĂ©s via radical `vok` → "voix" - - `kisun`, `kisiran` → trouvĂ©s via radical `kis` → "transmettre" - - `pasun` → trouvĂ© via radical `pas` → "prendre" - - `mirak` → trouvĂ© via radical `mir` → "voir" -- **Mots composĂ©s (dĂ©composition):** - - `sekavoki` → composition reconnue → "conseil" - - `siluuumi` → "oracle" - - `sekauaita` → "sagesse" -- **Particules grammaticales:** - - Toutes reconnues: `va`, `vo`, `na`, `at`, `su`, `se`, `ok`, `ul`, `ui`, `no`, `zo`, `zom` - - ✅ `ve` et `eol` maintenant documentĂ©s dans le lexique -- **Noms propres (castes, lieux):** - - `akoazana` → "faucons chasseurs" - - `aliaska` → "ailes-grises" - - `kekutoka` → "antres des Ă©chos" - - `uraakota` → "caste de l'eau / la confluence" -- **Vocabulaire spĂ©cialisĂ©:** - - `umitori` → "chaman" - - `vokiueka` → "proclamateur" - - `okitori` → "guerrier" - -### Mots non trouvĂ©s (7/122) - -#### Test en direct (2025-11-30): -```json -{ - "unknownWords": ["tiru", "sukamori", "kala", "uravis", "uraal", "kisaran", "vulu"], - "tokenCount": 122, - "unknownCount": 7, - "coverage": 94 -} -``` - -#### Analyse des 7 mots inconnus: - -**1. Mots potentiellement invalides (suffixes non existants):** -- `kisaran` - **⚠ PROBLÉMATIQUE** - utilise le suffixe `-aran` qui n'existe pas - - Note: `kisiran` (avec `-iran`) existe et signifie "transmettre/enseignement" - - HypothĂšse: Typo pour `kisiran` ? -- `uravis` - **⚠ PROBLÉMATIQUE** - utilise le suffixe `-vis` qui n'existe pas - - Aucun suffixe `-vis` documentĂ© dans la grammaire officielle - -**2. Compositions non dĂ©composĂ©es:** -- `sukamori` - composition potentielle `suk-a-mori` (forger + relation + ?) - - Le radical `suk` existe (forger), mais `mori` n'est pas documentĂ© -- `uraal` - composition potentielle `ur-aa-l` - - Le radical `ur` existe (eau), mais dĂ©composition incertaine - -**3. Mots complĂštement absents du lexique:** -- `tiru` - modificateur/adjectif ? Aucune occurrence dans les 765 entrĂ©es -- `kala` - mot inconnu, aucune racine similaire -- `vulu` - mot inconnu, aucune racine similaire - -**⚠ ALERTE - IncohĂ©rence linguistique confirmĂ©e (2025-11-30):** - -Test en direct sur le serveur confirme que ces 7 mots sont **absents du systĂšme de 765 entrĂ©es chargĂ©es**. - -**VĂ©rification exhaustive de la grammaire:** -- Les suffixes `aran` et `vis` **n'existent nulle part** dans la documentation officielle -- VĂ©rification dans: - - `ancien-confluent/docs/03-GRAMMAIRE.md` - Aucune mention - - `ancien-confluent/docs/02-MORPHOLOGIE.md` - Aucune mention - - Tous les 23 fichiers JSON du lexique - Aucune occurrence -- Conjugateurs documentĂ©s: `u`, `at`, `aan`, `ait`, `amat`, `en`, `il`, `eol`, `eon`, `eom`, `ok`, `es`, `ul`, `uv` -- Le suffixe `-iran` existe (ex: `kisiran`), mais `-aran` est **absent** - -**HypothĂšses sur l'origine:** -1. **Typos dans le texte de test** (probable pour `kisaran` → `kisiran`) -2. **Mots inventĂ©s pour le test** sans base linguistique -3. **Extensions de la langue** non encore documentĂ©es -4. **Racines complĂštes** Ă  documenter (pour `tiru`, `kala`, `vulu`) - -**Actions recommandĂ©es:** -- ❌ **NE PAS** ajouter `aran` et `vis` comme suffixes sans validation du crĂ©ateur de la langue -- ✅ VĂ©rifier si `kisaran` est une typo de `kisiran` -- ✅ Investiguer l'origine de `uravis` (composition ? nĂ©ologisme ?) -- ✅ DĂ©cider si `tiru`, `kala`, `vulu`, `sukamori`, `uraal` sont: - - Des erreurs Ă  corriger dans le texte de test - - Ou des mots lĂ©gitimes Ă  ajouter au lexique officiel - -## Traduction brute obtenue - -``` -va oracle vo grand (ou: vaste) conseil na faucons chasseurs (ou: faucons chasseurs, akoazana, faucon chasseur, faucons) voix (ou: parole, appeler) at va ailes-grises (ou: ailes-grises, aliaska, aile-grise, aile grise, ailes grises, ailes) vo voix (ou: parole, appeler) ancĂȘtre (ou: ancien, aĂŻeul, vieux, ĂągĂ©) na ancĂȘtre (ou: ancien, aĂŻeul, vieux, ĂągĂ©) zo transmettre (ou: enseigner, transmettent, transmis) at no antres des Ă©chos (ou: antres des Ă©chos, kekutoka) [INCONNU:tiru] guerrier vo loi (ou: rĂšgle, lieu, endroit, loup, zone, rĂ©gion) porter (ou: transporter) su famille (ou: clan) at tova vo caste de l'eau (ou: caste de l'eau, la confluence, uraakota, confluence (la)) na transmettre (ou: enseigner, transmettent, transmis) voix (ou: parole, appeler) at va chaman surveiller voir (ou: observer, regarder, vu, vus, vue, vues, verbe) at va grue (ou: Regard-Libre, grues, regard-libre) su vo poĂšme (ou: vers, chant) doux (ou: doux, tendre) su prendre (ou: prennent, pris, prisse) at va descendant (ou: descendant, futur, dĂ©butant, enfant) su vo serment (ou: serment, promesse, jurer) su prendre (ou: prennent, pris, prisse) at va grand (ou: vaste) [INCONNU:sukamori] vo arme grand (ou: vaste) su zo forger ul at va proclamateur (ou: proclamateur, proclamation) vo [INCONNU:kala] terrible [INCONNU:uravis] at na tova na [INCONNU:uraal] [INCONNU:kisaran] ui vo grand (ou: vaste) [INCONNU:vulu] prendre (ou: prennent, pris, prisse) ok se vo hall su alliĂ© (ou: alliĂ©, ami) tovak (ou: agir, faire, accomplir, crĂ©er, font, ferai, feras, fera, ferons, ferez, feront) ok se na transmettre (ou: enseigner, transmettent, transmis) zo ĂȘtre (ou: exister, vivre, il y a, y a-t-il, existe, existent, existant) u feu (ou: flamme, Ă©tincelle) na surveiller [INCONNU:ve] at zom na guerrier na grand (ou: vaste) [INCONNU:ve] at se va sagesse na homme (ou: homme, personne) su ui transmettre (ou: enseigner, transmettent, transmis) at [INCONNU:eol] -``` - -## Analyse du systĂšme implĂ©mentĂ© - -### Ce qui fonctionne ✅ - -1. **Recherche exacte** - Correspondance directe dans le lexique -2. **Recherche par radicaux verbaux** - Extraction de racines avec suffixes connus -3. **Index byFormeLiee** - Recherche rapide par forme liĂ©e -4. **Compositions simples** - Reconnaissance des mots composĂ©s documentĂ©s - -### Ce qui nĂ©cessite des amĂ©liorations 🔧 - -1. **⚠ Liste des suffixes verbaux** - ~~IncomplĂšte (manque `aran`, `vis`, etc.)~~ **ATTENTION:** Ces suffixes n'existent pas dans la grammaire officielle (voir alerte ci-dessus) -2. **DĂ©composition morphologique rĂ©cursive** - Ne trouve pas toutes les compositions -3. **Lexique** - Certains mots/particules manquants (`ve`, `eol` maintenant ajoutĂ©s - 2025-11-29) -4. **Validation du texte de test** - Contient des mots non conformes Ă  la grammaire Ă©tablie -5. **Confiance des matches** - SystĂšme de scoring pourrait ĂȘtre affinĂ© - -## Commande de test - -```bash -curl -s -X POST http://localhost:3000/api/translate/conf2fr \ - -H "Content-Type: application/json" \ - -d '{"text": "Va siluuumi vo mako sekavoki na akoazana vokan at. Va aliaska vo voki aita na aita zo kisun at. No kekutoka tiru okitori vo loku taku su mitak at. Tova vo uraakota na kisiran vokis at. Va umitori velu mirak at. Va alu su vo onuvoki melu su pasun at. Va naki su vo savu su pasun at. Va maku sukamori vo varu mako su zo sukam ul at. Va vokiueka vo kala okimako uravis at. Na tova na uraal kisaran ui vo mako vulu pasak ok se vo talu su vaku nekan ok. Se na kisiran zo urak u suki na velu ve at. Zom na okitori na mako ve at. Se va sekauaita na tori su ui kisun at eol."}' \ - | python3 -m json.tool -``` - -## Prochaines Ă©tapes pour atteindre 95%+ - -1. ✅ **Ajouter particules `ve` et `eol`** → +2% coverage (FAIT - 2025-11-29) -2. ❌ ~~**Enrichir VERBAL_SUFFIXES avec `aran`, `vis`**~~ → **ABANDONNÉ** - Ces suffixes n'existent pas linguistiquement -3. **⚠ PRIORITÉ: Valider/corriger le texte de test** - VĂ©rifier l'origine de `kisaran`, `uravis`, `sukamori`, `uraal` -4. **Documenter `tiru`, `kala`, `vulu`** → +3% coverage (si mots lĂ©gitimes) -5. **VĂ©rifier/ajouter racines pour compositions** → +1% coverage - -**Objectif atteint et rĂ©visĂ© (2025-11-30):** -- ✅ Coverage actuel confirmĂ©: **94%** (115/122) -- ✅ Particules `ve` et `eol` ajoutĂ©es avec succĂšs -- Coverage maximum thĂ©orique: **100%** si les 7 mots inconnus sont documentĂ©s -- **⚠ Attention:** Le texte de test contient probablement: - - 1-2 typos (`kisaran` → `kisiran` probable) - - 5-6 mots non documentĂ©s Ă  valider linguistiquement - -## Fichiers crĂ©Ă©s/modifiĂ©s - -### Nouveaux fichiers -- `ConfluentTranslator/radicalMatcher.js` - Extraction de radicaux -- `ConfluentTranslator/morphologicalDecomposer.js` - DĂ©composition morphologique - -### Fichiers modifiĂ©s -- `ConfluentTranslator/reverseIndexBuilder.js` - Ajout index `byFormeLiee` -- `ConfluentTranslator/confluentToFrench.js` - Recherche en cascade - -### Structure de l'index -```javascript -{ - byWord: { - "voki": { francais: "voix", forme_liee: "vok", ... } - }, - byFormeLiee: { - "vok": [ - { francais: "voix", matchType: "forme_liee", ... } - ] - } -} -``` - -## Conclusion - -### ✅ SystĂšme de recherche par radicaux : OPÉRATIONNEL - -Le systĂšme est **fonctionnel, testĂ© et validĂ©** : -- **AmĂ©lioration:** 83% → 94% de coverage (+11 points) -- **Mots trouvĂ©s:** 115/122 tokens -- **Architecture:** Recherche en cascade Ă  4 niveaux (exact → radicaux → dĂ©composition → inconnu) -- **Performance:** SystĂšme robuste avec 765 entrĂ©es de lexique chargĂ©es - -### 📊 RĂ©sultats du test en direct (2025-11-30) - -**Test effectuĂ© avec serveur Node.js:** -```bash -curl -X POST http://localhost:3000/api/translate/conf2fr -``` - -**RĂ©sultats confirmĂ©s:** -- Coverage: **94%** (115/122) -- Mots inconnus: **7** (`tiru`, `sukamori`, `kala`, `uravis`, `uraal`, `kisaran`, `vulu`) -- Toutes les particules grammaticales reconnues (✅ `ve` et `eol` ajoutĂ©s) -- DĂ©composition morphologique fonctionnelle -- Recherche par radicaux opĂ©rationnelle - -### ⚠ DĂ©couverte importante : ProblĂšmes dans le texte de test - -**Analyse exhaustive rĂ©vĂšle que le texte de test contient des anomalies linguistiques :** - -1. **Suffixes inexistants** (2 mots): - - `kisaran` utilise `-aran` (n'existe pas, probable typo de `kisiran`) - - `uravis` utilise `-vis` (n'existe pas dans la grammaire) - -2. **Mots non documentĂ©s** (5 mots): - - `tiru`, `kala`, `vulu` - absents des 765 entrĂ©es - - `sukamori`, `uraal` - compositions incomplĂštes - -**VĂ©rification complĂšte effectuĂ©e:** -- ✅ 765 entrĂ©es de lexique chargĂ©es et indexĂ©es -- ✅ Documentation grammaire officielle consultĂ©e -- ✅ Aucune trace de `-aran` ou `-vis` dans les conjugateurs documentĂ©s - -### 🎯 Actions recommandĂ©es avant production - -1. **IMMÉDIAT:** - - ✅ Particules `ve` et `eol` ajoutĂ©es au lexique → Coverage 94% - - ⚠ **Valider l'origine du texte de test** avec le crĂ©ateur de la langue - -2. **PROCHAINES ÉTAPES:** - - Option A: **Corriger les typos** dans le texte (`kisaran` → `kisiran`) - - Option B: **Documenter les nouveaux mots** s'ils sont intentionnels - - Option C: **CrĂ©er un nouveau texte de test** 100% conforme Ă  la grammaire - -3. **LONG TERME:** - - Enrichir le lexique avec les mots manquants lĂ©gitimes - - AmĂ©liorer la dĂ©composition morphologique rĂ©cursive - - Affiner le systĂšme de scoring de confiance - -### 📈 État actuel du systĂšme - -| Composant | État | Performance | -|-----------|------|-------------| -| Recherche exacte | ✅ OpĂ©rationnel | 100% | -| Recherche par radicaux | ✅ OpĂ©rationnel | ~95% | -| DĂ©composition morphologique | ✅ OpĂ©rationnel | ~85% | -| Index byFormeLiee | ✅ OpĂ©rationnel | 100% | -| Coverage global | ✅ **94%** | Objectif atteint | - -**SystĂšme technique: ✅ PRÊT POUR PRODUCTION** -**Texte de test: ⚠ NÉCESSITE VALIDATION LINGUISTIQUE** diff --git a/ConfluentTranslator/docs/dev/analysis/ANALYSE_MOTS_PROBLEMATIQUES.md b/ConfluentTranslator/docs/dev/analysis/ANALYSE_MOTS_PROBLEMATIQUES.md deleted file mode 100644 index 978e36f..0000000 --- a/ConfluentTranslator/docs/dev/analysis/ANALYSE_MOTS_PROBLEMATIQUES.md +++ /dev/null @@ -1,241 +0,0 @@ -# Analyse des mots problĂ©matiques du texte de test - -Date: 2025-11-29 - -## Contexte - -Le texte de test (122 tokens) contient 10 mots non trouvĂ©s. Analyse approfondie de chaque mot pour dĂ©terminer s'ils sont lĂ©gitimes ou erronĂ©s. - ---- - -## Mots analysĂ©s - -### 1. `tiru` ✅ RÉSOLU -**Statut**: LĂ©gitime - Nombre existant -**Source**: `ancien-confluent/lexique/22-nombres.json` ligne 32 -**Valeur**: 3 (trois) -**Contexte dans le texte**: `No kekutoka tiru okitori...` = "Dans antres-des-Ă©chos trois guerrier..." -**Action**: ✅ Ajouter au dictionnaire principal si absent - ---- - -### 2. `kisiran` vs `kisaran` ⚠ INCOHÉRENCE DÉTECTÉE - -**Analyse comparative**: - -| Forme | Statut | Source | DĂ©composition | -|-------|--------|--------|---------------| -| `kisiran` | ✅ TrouvĂ© dans le texte (ligne 8) | Texte de test | `kis-iran` (transmettre + ?) | -| `kisaran` | ❌ Non trouvĂ© (ligne 10) | Texte de test | `kis-aran` (transmettre + ?) | - -**Verbe de base**: -- `kisun` = transmettre, enseigner (verbe CVCVC) -- Racine: `kisu` -- Forme liĂ©e: `kis` -- Source: `ancien-confluent/lexique/06-actions.json` ligne 123 - -**ProblĂšme**: -- Le texte contient **deux formes diffĂ©rentes**: `kisiran` ET `kisaran` -- Aucun des deux suffixes (`iran`, `aran`) n'est documentĂ© dans la grammaire -- Seul `iran` apparaĂźt dans `radicalMatcher.js` comme "dĂ©rivĂ© nominal" - -**HypothĂšses**: -1. **Typo**: `kisaran` est une erreur de frappe pour `kisiran` -2. **Variantes**: Deux formes diffĂ©rentes intentionnelles (non documentĂ©es) -3. **Erreur de conception**: Suffixes inventĂ©s sans base linguistique - -**Recommandation**: ⚠ VĂ©rifier avec le crĂ©ateur du texte - probablement une typo - ---- - -### 3. `uravis` ❌ NON DOCUMENTÉ - -**DĂ©composition supposĂ©e**: `ura-vis` - -**Racine `ura`**: -- ✅ Existe: Racine sacrĂ©e "eau, flux, vie" -- Source: `ancien-confluent/lexique/01-racines-sacrees.json` -- Forme liĂ©e: `ur` - -**Suffixe `vis`**: -- ❌ N'existe PAS dans la grammaire officielle -- Absent de tous les conjugateurs documentĂ©s -- Aucune occurrence dans le lexique - -**Contexte**: `Va vokiueka vo kala okimako uravis at` - -**HypothĂšses**: -1. Mot complet non documentĂ© (pas un dĂ©rivĂ©) -2. Composition mal formĂ©e -3. Erreur dans le texte de test - -**Recommandation**: ❌ À corriger ou documenter - ---- - -### 4. `sukamori` ❌ NON DOCUMENTÉ - -**DĂ©composition supposĂ©e**: `suk-a-mori` - -**Racine `suk`**: -- ✅ Existe: "feu, forge" -- Verbe: `sukam` = forger -- Source: `ancien-confluent/lexique/06-actions.json` ligne 334 -- Forme liĂ©e: `suk` - -**Liaison `a`**: -- ✅ Liaison sacrĂ©e existante (relation) - -**Racine `mori`**: -- ❌ N'existe PAS dans le lexique -- Recherche exhaustive: aucune occurrence - -**Contexte**: `Va maku sukamori vo varu mako su zo sukam ul at` -= "Le grand sukamori l'arme grande... a forgĂ© (passĂ©)" - -**HypothĂšses**: -1. `mori` = racine non documentĂ©e (forgeron? artisan?) -2. Composition erronĂ©e -3. Devrait ĂȘtre autre chose - -**Recommandation**: ❌ Racine `mori` manquante - Ă  documenter ou corriger - ---- - -### 5. `uraal` ❌ NON DOCUMENTÉ - -**DĂ©composition supposĂ©e**: `ur-aa-l` ou `ura-al` - -**Racine `ur`/`ura`**: -- ✅ Existe: Racine sacrĂ©e "eau, flux, vie" -- Forme liĂ©e: `ur` - -**Liaison `aa`**: -- ✅ Liaison sacrĂ©e existante (relation forte) - -**Partie finale `l` ou racine `al`**: -- ❌ Aucune racine `al` trouvĂ©e dans le lexique -- Un simple `l` ne peut pas ĂȘtre une racine (trop court) - -**Contexte**: `Na tova na uraal kisaran ui...` - -**HypothĂšses**: -1. Composition mal formĂ©e -2. Racine `al` non documentĂ©e -3. Erreur de construction - -**Recommandation**: ❌ Structure invalide - Ă  corriger - ---- - -### 6. `kala` ❌ NON DOCUMENTÉ - -**Recherche**: -- ❌ Aucune occurrence dans tout le lexique -- Pas de racine `kal` trouvĂ©e -- Structure valide (CV-CV) mais absente - -**Contexte**: `Va vokiueka vo kala okimako uravis at` - -**HypothĂšses**: -1. Mot non documentĂ© (adjectif? nom?) -2. Erreur ou invention - -**Recommandation**: ❌ À documenter ou corriger - ---- - -### 7. `vulu` ❌ NON DOCUMENTÉ - -**Recherche**: -- ❌ Aucune occurrence dans tout le lexique -- Pas de racine `vul` trouvĂ©e -- Structure valide (CV-CV) mais absente - -**Contexte**: `vo mako vulu pasak ok` - -**HypothĂšses**: -1. Mot non documentĂ© (adjectif? nom?) -2. Erreur ou invention - -**Recommandation**: ❌ À documenter ou corriger - ---- - -## RĂ©sumĂ© des dĂ©couvertes - -### Mots lĂ©gitimes (1/7) -| Mot | Statut | Source | Action | -|-----|--------|--------|--------| -| `tiru` | ✅ Nombre = 3 | `22-nombres.json` | Ajouter au lexique principal | - -### ProblĂšmes dĂ©tectĂ©s (6/7) - -| Mot | Type de problĂšme | SĂ©vĂ©ritĂ© | Action recommandĂ©e | -|-----|------------------|----------|-------------------| -| `kisaran` | Suffixe inexistant `aran` | ⚠ Haute | Probablement typo de `kisiran` | -| `uravis` | Suffixe inexistant `vis` | ⚠ Haute | Corriger ou documenter | -| `sukamori` | Racine `mori` manquante | 🔮 Critique | Documenter `mori` ou corriger | -| `uraal` | Composition invalide | 🔮 Critique | Corriger la structure | -| `kala` | Mot totalement absent | 🔮 Critique | Documenter ou supprimer | -| `vulu` | Mot totalement absent | 🔮 Critique | Documenter ou supprimer | - ---- - -## Recommandations - -### Option A: Corriger le texte de test -Remplacer les mots non documentĂ©s par des Ă©quivalents conformes Ă  la grammaire Ă©tablie. - -**Avantages**: -- Maintient la cohĂ©rence linguistique -- Texte de test devient une rĂ©fĂ©rence fiable -- Coverage peut atteindre 98-100% - -**InconvĂ©nients**: -- Perd le texte original si celui-ci Ă©tait intentionnel - -### Option B: Documenter les nouveaux mots -Si ces mots sont des extensions lĂ©gitimes non documentĂ©es, les ajouter au lexique. - -**Avantages**: -- Enrichit la langue -- PrĂ©serve le texte original - -**InconvĂ©nients**: -- NĂ©cessite validation linguistique -- Doit dĂ©finir les suffixes `aran` et `vis` grammaticalement -- Risque d'incohĂ©rences si ajoutĂ©s sans rĂ©flexion - -### Option C: Validation hybride -1. ✅ Ajouter `tiru` au dictionnaire principal (nombre lĂ©gitime) -2. ⚠ Corriger `kisaran` → `kisiran` (probable typo) -3. 🔮 Demander validation pour `sukamori`, `uraal`, `kala`, `vulu`, `uravis` - ---- - -## Impact sur le coverage - -### ScĂ©nario actuel (avec ve/eol ajoutĂ©s) -- Coverage: **94%** (114/122) -- Mots non trouvĂ©s: 8 - -### ScĂ©nario A: Correction du texte -- Coverage potentiel: **98-100%** -- DĂ©pend des corrections apportĂ©es - -### ScĂ©nario B: Documentation des nouveaux mots -- Coverage potentiel: **98-100%** -- Mais risque d'incohĂ©rences grammaticales - ---- - -## Conclusion - -Le texte de test contient **6 mots problĂ©matiques non conformes** Ă  la grammaire documentĂ©e. Avant de pousser le coverage Ă  95%+, il est **critique** de: - -1. ✅ Valider l'origine et l'intentionnalitĂ© du texte -2. ⚠ DĂ©cider: correction vs documentation -3. 🔮 Ne PAS ajouter de suffixes (`aran`, `vis`) sans validation linguistique formelle - -**Statut actuel du traducteur**: ✅ Robuste et fonctionnel (94% coverage avec grammaire validĂ©e) diff --git a/ConfluentTranslator/plans/radical-lookup-system.md b/ConfluentTranslator/plans/radical-lookup-system.md deleted file mode 100644 index 119fa87..0000000 --- a/ConfluentTranslator/plans/radical-lookup-system.md +++ /dev/null @@ -1,415 +0,0 @@ -# Plan : SystĂšme de recherche par radicaux et dĂ©composition morphologique - -## ProblĂšme actuel - -Le traducteur Confluent→Français ne trouve pas les mots conjuguĂ©s ou composĂ©s non documentĂ©s explicitement dans le lexique. - -### Exemple concret -- **Texte :** `vokan` (forme conjuguĂ©e de "voki" = voix) -- **Lexique contient :** `"confluent": "voki"`, `"forme_liee": "vok"` -- **RĂ©sultat actuel :** ❌ NOT FOUND -- **RĂ©sultat attendu :** ✓ Trouve "voki" via le radical "vok" - -### Statistiques du dernier test -- **Coverage actuel :** 83% (101/122 mots) -- **Mots non trouvĂ©s :** 21 - - **11** ont des racines existantes mais formes conjuguĂ©es manquantes - - **5** sont totalement absents du lexique - - **5** pourraient ĂȘtre des particules grammaticales - -## Objectif - -Augmenter le coverage de 83% Ă  ~95% en implĂ©mentant : -1. **Recherche par radicaux** pour les verbes conjuguĂ©s -2. **DĂ©composition morphologique** pour les compositions non documentĂ©es -3. **Index par forme_liee** en plus de l'index par mot complet - ---- - -## Phase 1 : Analyse et mapping des patterns - -### 1.1 Patterns de conjugaison verbale - -**Suffixes verbaux identifiĂ©s :** -```javascript -const VERBAL_SUFFIXES = [ - 'ak', // forme standard : mirak (voir), pasak (prendre), urak (ĂȘtre) - 'an', // conjugaison : takan (porter), vokan (parler?) - 'un', // conjugaison : kisun (transmettre), pasun (prendre?) - 'is', // conjugaison : vokis (parler?) - 'am', // conjugaison : sukam (forger) - 'im', // conjugaison : verim (vĂ©rifier?) - 'ok', // impĂ©ratif : marqueur temporel - 'ul', // passĂ©? : marqueur temporel - 'iran', // dĂ©rivĂ© nominal : kisiran (enseignement/transmission?) -]; -``` - -**Racines de test connues :** -- `vok` → `voki` (voix) : formes attendues `vokan`, `vokis` -- `kis` → `kisu` (transmettre) : formes attendues `kisun`, `kisiran` -- `pas` → `pasa` (prendre) : formes attendues `pasak`, `pasun` -- `tak` → `taka` (porter) : formes attendues `takan`, `taku` - -### 1.2 Patterns de liaisons sacrĂ©es - -**16 liaisons Ă  gĂ©rer :** -```javascript -const SACRED_LIAISONS = { - // AgentivitĂ© - 'i': 'agent', - 'ie': 'agent_processus', - 'ii': 'agent_rĂ©pĂ©tĂ©', - 'iu': 'agent_possĂ©dant', - - // Appartenance - 'u': 'appartenance', - 'ui': 'possession_agentive', - - // Relation - 'a': 'relation', - 'aa': 'relation_forte', - 'ae': 'relation_dimensionnelle', - 'ao': 'relation_tendue', - - // Tension - 'o': 'tension', - 'oa': 'tension_relationnelle', - - // Dimension - 'e': 'dimension', - 'ei': 'dimension_agentive', - 'ea': 'dimension_relationnelle', - 'eo': 'dimension_tendue' -}; -``` - -### 1.3 Structure morphologique du Confluent - -**RĂšgle gĂ©nĂ©rale :** Racine + Liaison + Racine -``` -sekavoki = sek + a + voki - = conseil + relation + voix - = "conseil de la voix" -``` - -**Pattern de composition :** -```regex -^([a-z]{2,4})(i|ie|ii|iu|u|ui|a|aa|ae|ao|o|oa|e|ei|ea|eo)([a-z]{2,4})$ -``` - ---- - -## Phase 2 : ImplĂ©mentation - -### 2.1 Nouveau fichier : `radicalMatcher.js` - -**Fonction principale :** -```javascript -/** - * Extrait tous les radicaux possibles d'un mot - * @param {string} word - Mot en confluent - * @returns {Array<{radical: string, suffix: string, confidence: number}>} - */ -function extractRadicals(word) { - const candidates = []; - - // Essayer chaque suffixe verbal connu - for (const suffix of VERBAL_SUFFIXES) { - if (word.endsWith(suffix) && word.length > suffix.length + 1) { - const radical = word.slice(0, -suffix.length); - candidates.push({ - radical, - suffix, - type: 'verbal', - confidence: 0.9 - }); - } - } - - // Essayer sans suffixe (forme racine directe) - if (word.length >= 3) { - candidates.push({ - radical: word, - suffix: '', - type: 'root', - confidence: 0.7 - }); - } - - // Essayer d'enlever derniĂšre voyelle (forme liĂ©e -> forme pleine) - // mako → mak, voki → vok - if (word.length >= 4 && 'aeiou'.includes(word[word.length - 1])) { - candidates.push({ - radical: word.slice(0, -1), - suffix: word[word.length - 1], - type: 'liaison', - confidence: 0.8 - }); - } - - return candidates.sort((a, b) => b.confidence - a.confidence); -} -``` - -### 2.2 Nouveau fichier : `morphologicalDecomposer.js` - -**Fonction de dĂ©composition :** -```javascript -/** - * DĂ©compose un mot composĂ© non trouvĂ© - * @param {string} word - Mot composĂ© - * @returns {Array<{part1: string, liaison: string, part2: string}>} - */ -function decomposeWord(word) { - const decompositions = []; - - for (const [liaison, meaning] of Object.entries(SACRED_LIAISONS)) { - const index = word.indexOf(liaison); - - if (index > 0 && index < word.length - liaison.length) { - const part1 = word.substring(0, index); - const part2 = word.substring(index + liaison.length); - - // Valider que les deux parties ressemblent Ă  des racines - if (part1.length >= 2 && part2.length >= 2) { - decompositions.push({ - part1, - liaison, - liaisonMeaning: meaning, - part2, - pattern: `${part1}-${liaison}-${part2}`, - confidence: calculateConfidence(part1, liaison, part2) - }); - } - } - } - - return decompositions.sort((a, b) => b.confidence - a.confidence); -} - -function calculateConfidence(part1, liaison, part2) { - let score = 0.5; // base - - // Bonus si les parties finissent/commencent par des consonnes - if (!'aeiou'.includes(part1[part1.length - 1])) score += 0.1; - if (!'aeiou'.includes(part2[0])) score += 0.1; - - // Bonus si liaison courante (i, u, a sont plus frĂ©quentes) - if (['i', 'u', 'a'].includes(liaison)) score += 0.2; - - // Bonus si longueurs de parties Ă©quilibrĂ©es - const ratio = Math.min(part1.length, part2.length) / Math.max(part1.length, part2.length); - score += ratio * 0.2; - - return Math.min(score, 1.0); -} -``` - -### 2.3 Modification : `reverseIndexBuilder.js` - -**Ajouter index par forme_liee :** -```javascript -function buildConfluentIndex(lexique) { - const index = { - byWord: {}, // Index existant - byRoot: {}, // NOUVEAU : index par radical - byFormeLiee: {} // NOUVEAU : index par forme_liee - }; - - // ... code existant pour byWord ... - - // NOUVEAU : Indexer par forme_liee - for (const entry of allEntries) { - const formeLiee = entry.forme_liee || entry.racine; - if (formeLiee) { - if (!index.byFormeLiee[formeLiee]) { - index.byFormeLiee[formeLiee] = []; - } - index.byFormeLiee[formeLiee].push({ - ...entry, - matchType: 'forme_liee' - }); - } - } - - return index; -} -``` - -### 2.4 Modification : `confluentToFrench.js` - -**Nouvelle logique de recherche en cascade :** -```javascript -function findWordWithRadicals(word, confluentIndex) { - // 1. Recherche exacte (existant) - if (confluentIndex.byWord[word]) { - return { - ...confluentIndex.byWord[word][0], - matchType: 'exact', - confidence: 1.0 - }; - } - - // 2. NOUVEAU : Recherche par radicaux verbaux - const radicals = extractRadicals(word); - for (const {radical, suffix, type, confidence} of radicals) { - // Chercher dans l'index par forme_liee - if (confluentIndex.byFormeLiee[radical]) { - return { - ...confluentIndex.byFormeLiee[radical][0], - matchType: 'radical', - originalWord: word, - radical, - suffix, - suffixType: type, - confidence - }; - } - } - - // 3. NOUVEAU : DĂ©composition morphologique - const decompositions = decomposeWord(word); - for (const decomp of decompositions) { - const part1Match = findWordWithRadicals(decomp.part1, confluentIndex); - const part2Match = findWordWithRadicals(decomp.part2, confluentIndex); - - if (part1Match && part2Match) { - return { - matchType: 'composition_inferred', - originalWord: word, - composition: `${decomp.part1}-${decomp.liaison}-${decomp.part2}`, - parts: { - part1: part1Match, - liaison: decomp.liaison, - liaisonMeaning: decomp.liaisonMeaning, - part2: part2Match - }, - confidence: decomp.confidence * 0.7 // PĂ©nalitĂ© pour infĂ©rence - }; - } - } - - // 4. Vraiment inconnu - return null; -} -``` - ---- - -## Phase 3 : Tests et validation - -### 3.1 Cas de test prioritaires - -**Verbes conjuguĂ©s :** -```javascript -const testCases = [ - { word: 'vokan', expectedRoot: 'vok', expectedMeaning: 'voix' }, - { word: 'vokis', expectedRoot: 'vok', expectedMeaning: 'voix' }, - { word: 'kisiran', expectedRoot: 'kis', expectedMeaning: 'transmettre' }, - { word: 'pasun', expectedRoot: 'pas', expectedMeaning: 'prendre' }, - { word: 'taku', expectedRoot: 'tak', expectedMeaning: 'porter' }, -]; -``` - -**Compositions infĂ©rĂ©es :** -```javascript -const compositionTests = [ - { - word: 'sukamori', - expected: { part1: 'suk', liaison: 'a', part2: 'mori' }, - // Si 'mori' existe dans le lexique - }, - { - word: 'uraal', - expected: { part1: 'ur', liaison: 'aa', part2: 'al' } - } -]; -``` - -### 3.2 MĂ©triques de succĂšs - -**Objectif :** Passer de 83% Ă  95% de coverage - -**MĂ©triques Ă  suivre :** -- Coverage total (% de mots trouvĂ©s) -- PrĂ©cision (% de correspondances correctes) -- Type de match (exact / radical / composition) -- Niveau de confiance moyen - ---- - -## Phase 4 : Fichiers Ă  crĂ©er/modifier - -### Fichiers Ă  CRÉER : -1. `ConfluentTranslator/radicalMatcher.js` -2. `ConfluentTranslator/morphologicalDecomposer.js` -3. `ConfluentTranslator/tests/radicalMatching.test.js` - -### Fichiers Ă  MODIFIER : -1. `ConfluentTranslator/reverseIndexBuilder.js` - - Ajouter index `byFormeLiee` - - Ajouter index `byRoot` - -2. `ConfluentTranslator/confluentToFrench.js` - - Importer `radicalMatcher` et `morphologicalDecomposer` - - Modifier `translateToken()` pour utiliser recherche en cascade - - Ajouter champs de mĂ©tadonnĂ©es (matchType, confidence, etc.) - -3. `ConfluentTranslator/server.js` - - Aucune modification nĂ©cessaire (compatibilitĂ© backwards) - ---- - -## Phase 5 : AmĂ©liorations futures - -### 5.1 Machine Learning lĂ©ger -- Apprendre les patterns de suffixes depuis le corpus -- Scorer automatiquement la confiance des dĂ©compositions - -### 5.2 Support des nombres -- Charger `22-nombres.json` dans le lexique -- GĂ©rer les nombres composĂ©s (ex: "diku tolu iko" = 25) - -### 5.3 Particules grammaticales -- Documenter `ve`, `eol`, et autres particules manquantes -- CrĂ©er un fichier `particules.json` - -### 5.4 Interface de validation -- UI pour valider/corriger les correspondances infĂ©rĂ©es -- Export des nouvelles correspondances pour enrichir le lexique - ---- - -## Ordre d'implĂ©mentation recommandĂ© - -1. ✅ CrĂ©er `radicalMatcher.js` avec fonction `extractRadicals()` -2. ✅ Modifier `reverseIndexBuilder.js` pour ajouter `byFormeLiee` -3. ✅ Modifier `confluentToFrench.js` pour recherche par radical -4. ✅ Tester avec les 11 cas de verbes conjuguĂ©s -5. ✅ CrĂ©er `morphologicalDecomposer.js` avec fonction `decomposeWord()` -6. ✅ IntĂ©grer dĂ©composition dans `confluentToFrench.js` -7. ✅ Tester avec les compositions infĂ©rĂ©es -8. ✅ Ajouter support des nombres (`22-nombres.json`) -9. 🔄 Valider sur le texte complet (objectif: 95% coverage) - ---- - -## Impact attendu - -### Sur le texte de test (122 tokens) -**Avant :** -- Coverage: 83% (101/122) -- Inconnus: 21 - -**AprĂšs (estimation) :** -- Coverage: ~95% (116/122) -- Inconnus: ~6 -- Avec confiance: ~110/122 -- InfĂ©rĂ©s: ~6/122 - -### BĂ©nĂ©fices -- ✅ Meilleure comprĂ©hension des textes rĂ©els -- ✅ DĂ©couverte automatique de nouvelles formes -- ✅ Base pour enrichissement du lexique -- ✅ System plus robuste et adaptatif diff --git a/ConfluentTranslator/proto-confluent b/ConfluentTranslator/proto-confluent deleted file mode 120000 index e5252c7..0000000 --- a/ConfluentTranslator/proto-confluent +++ /dev/null @@ -1 +0,0 @@ -../proto-confluent \ No newline at end of file diff --git a/ConfluentTranslator/proto-confluent b/ConfluentTranslator/proto-confluent new file mode 100644 index 0000000..e5252c7 --- /dev/null +++ b/ConfluentTranslator/proto-confluent @@ -0,0 +1 @@ +../proto-confluent \ No newline at end of file diff --git a/docs/GUIDE_UTILISATION.md b/docs/GUIDE_UTILISATION.md new file mode 100644 index 0000000..13a5673 --- /dev/null +++ b/docs/GUIDE_UTILISATION.md @@ -0,0 +1,228 @@ +# Guide d'utilisation - Projet Confluent + +Ce guide vous explique comment utiliser le projet Confluent, un systĂšme de langue construite pour la Civilisation de la Confluence. + +## Qu'est-ce que le Confluent ? + +Le Confluent est une **langue construite** (conlang) crĂ©Ă©e pour la Civilisation de la Confluence, une civilisation fictive du projet de jeu de rĂŽle **civjdr**. + +La langue reflĂšte les valeurs profondes de cette civilisation : +- **L'observation** : "regarder avant d'agir" +- **La transmission** : le savoir partagĂ© de gĂ©nĂ©ration en gĂ©nĂ©ration +- **La mĂ©moire** : ne rien oublier des ancĂȘtres et de leur sagesse +- **La confluence** : la force naĂźt de la rencontre et du mĂ©lange + +Le projet comprend deux composantes : +1. **Une langue complĂšte** avec phonologie, morphologie, grammaire et lexique +2. **Un traducteur web** (ConfluentTranslator) pour traduire entre français et confluent via LLM + +## Installation rapide + +### PrĂ©requis + +- **Node.js** version 14 ou supĂ©rieure +- AccĂšs Ă  une API LLM (Anthropic Claude ou OpenAI) + +### Étapes d'installation + +1. **Cloner le dĂ©pĂŽt** +```bash +git clone +cd confluent +``` + +2. **Installer les dĂ©pendances** +```bash +cd ConfluentTranslator +npm install +``` + +3. **Configurer les clĂ©s API** + +CrĂ©er un fichier `.env` Ă  la racine du projet (parent de ConfluentTranslator) : + +```env +ANTHROPIC_API_KEY=votre_cle_anthropic +OPENAI_API_KEY=votre_cle_openai +``` + +4. **Lancer le serveur** +```bash +npm start +``` + +Le serveur dĂ©marre sur http://localhost:3000 + +## Utiliser l'interface web + +### AccĂšs + +Ouvrir http://localhost:3000 dans votre navigateur. + +### Configuration + +1. **Choisir le provider LLM** : Anthropic ou OpenAI +2. **SĂ©lectionner le modĂšle** : selon le provider choisi +3. **Choisir la variante de langue** : + - **Proto-Confluent** : langue primitive des premiers clans (phonologie rĂ©duite, syntaxe simple) + - **Ancien Confluent** : langue unifiĂ©e avec liaisons sacrĂ©es et systĂšme verbal complet + +### Traduire + +1. Entrer votre texte français dans le champ de texte +2. Cliquer sur "Traduire" +3. Le rĂ©sultat apparaĂźt avec plusieurs niveaux d'analyse : + - **Layer 1** : Traduction directe + - **Layer 2** : Analyse contextuelle + - **Layer 3** : Traduction finale avec contexte + +Votre configuration est sauvegardĂ©e automatiquement dans le navigateur. + +## Utiliser l'API + +### Exemple simple de traduction + +```bash +curl -X POST http://localhost:3000/translate \ + -H "Content-Type: application/json" \ + -d '{ + "text": "Bonjour, je suis un voyageur", + "variant": "ancien", + "provider": "anthropic", + "model": "claude-3-5-sonnet-20241022" + }' +``` + +### Endpoints principaux + +- **POST /translate** - Traduction FR → Confluent +- **POST /api/translate/conf2fr** - Traduction Confluent → FR +- **GET /api/search** - Recherche dans le lexique +- **POST /api/analyze/coverage** - Analyse de couverture lexicale + +Pour plus de dĂ©tails sur l'API, consultez [docs/API.md](../ConfluentTranslator/docs/API.md) ou CLAUDE.md. + +## Explorer la langue + +### Documentation linguistique complĂšte + +La documentation de l'Ancien Confluent se trouve dans `ancien-confluent/docs/` : + +1. **01-PHONOLOGIE.md** - Sons, consonnes, voyelles +2. **02-MORPHOLOGIE.md** - Racines et liaisons sacrĂ©es +3. **03-GRAMMAIRE.md** - Verbes, conjugaisons, particules +4. **04-SYNTAXE.md** - Construction de phrases, nĂ©gation, questions +5. **05-VOCABULAIRE.md** - Lexique complet validĂ© +6. **06-ADJECTIFS.md** - SystĂšme adjectival + +### Consulter le lexique + +Le lexique JSON complet est disponible dans : +- `ancien-confluent/lexique/lexique-ancien-complet.json` +- `proto-confluent/lexique/lexique-proto-complet.json` + +Vous pouvez Ă©galement consulter : +- `docs/LEXIQUE_REFERENCE_CONFLUENCE.md` - Vocabulaire de rĂ©fĂ©rence +- `ancien-confluent/docs/06-LEXIQUE-COMPLET.md` - Version markdown + +### Formules rituelles + +Consultez `docs/FORMULES_RITUELLES.md` pour les expressions sacrĂ©es et formules de la civilisation. + +### Contexte culturel + +Pour comprendre la civilisation et ses valeurs, lisez `docs/culture/CONTEXTE_CIVILISATION.md`. + +## Contribuer + +### Structure du projet + +``` +confluent/ +├── ancien-confluent/ # Langue unifiĂ©e +│ ├── docs/ # Documentation complĂšte +│ └── lexique/ # Fichiers JSON +├── proto-confluent/ # Langue primitive +│ ├── docs/ +│ └── lexique/ +├── ConfluentTranslator/ # Serveur de traduction +│ ├── src/ # Code source organisĂ© +│ ├── public/ # Interface web +│ └── prompts/ # Prompts systĂšme LLM +├── docs/ # Documentation gĂ©nĂ©rale +│ ├── culture/ # Contexte civilisationnel +│ └── archive/ +└── data/ # DonnĂ©es partagĂ©es +``` + +### Ajouter du vocabulaire + +Pour enrichir le lexique : + +1. **Éditer le fichier JSON** appropriĂ© : + - `ancien-confluent/lexique/lexique-ancien-complet.json` + - `proto-confluent/lexique/lexique-proto-complet.json` + +2. **Respecter la structure** : +```json +{ + "mot_francais": "traduction_confluent" +} +``` + +3. **Suivre les rĂšgles linguistiques** : + - Toute racine finit par CV (consonne + voyelle) + - ~80% racines standard (commence par consonne) + - ~20% racines sacrĂ©es (commence par voyelle) + - Pas de majuscules en confluent + - Consonnes autorisĂ©es : b, k, l, m, n, p, s, t, v, z + - Voyelles : a, e, i, o, u + +4. **RĂ©gĂ©nĂ©rer le lexique complet** (si applicable) : +```bash +cd ancien-confluent +node generer-lexique-complet.js +``` + +5. **Tester** : +```bash +cd ConfluentTranslator +npm start +# Puis tester la traduction via l'interface +``` + +### Tests + +Pour lancer les tests : +```bash +cd ConfluentTranslator/tests +# Voir scripts disponibles +``` + +## Ressources utiles + +### Documentation technique +- **CLAUDE.md** - Guide pour Claude Code +- **ConfluentTranslator/STRUCTURE.md** - Architecture du traducteur +- **ConfluentTranslator/README.md** - Documentation du serveur + +### Documentation linguistique +- **docs/SYSTEM_PROMPT_LLM.md** - Prompt systĂšme complet pour LLM +- **docs/SYSTEME_NUMERIQUE_BASE12.md** - SystĂšme de nombres +- **docs/EMOTIONS_METAPHORES.md** - Vocabulaire Ă©motionnel + +### HĂ©bergement +- **HEBERGEMENT.md** - Guide d'hĂ©bergement complet + +## Support et questions + +Pour toute question ou problĂšme : +1. Consulter la documentation dans `docs/` et `ancien-confluent/docs/` +2. VĂ©rifier les issues existantes +3. CrĂ©er une nouvelle issue avec tag appropriĂ© + +## Philosophie du projet + +Le Confluent n'est pas qu'une langue : c'est un **artefact multi-gĂ©nĂ©rationnel**, comme la Grande Fresque de la civilisation. Chaque contribution ajoute une couche de sens, enrichit le systĂšme, et transmet le savoir. + +Comme le disent les Siliaska : **"Observer, apprendre, transmettre"**. diff --git a/docs/PROMPT_CONTEXTUEL_INTELLIGENT.md b/docs/PROMPT_CONTEXTUEL_INTELLIGENT.md deleted file mode 100644 index 5f54f9e..0000000 --- a/docs/PROMPT_CONTEXTUEL_INTELLIGENT.md +++ /dev/null @@ -1,500 +0,0 @@ -# Plan d'ImplĂ©mentation : Prompt Contextuel Intelligent - -## Situation Actuelle - -**ProblĂšme** : Le systĂšme injecte tout le lexique (516 entrĂ©es ancien + 164 proto) dans le prompt systĂšme, ce qui : -- Consomme Ă©normĂ©ment de tokens -- CoĂ»te cher -- Est inefficace (99% du lexique est inutile pour une phrase donnĂ©e) - -**État actuel** : -- `buildEnhancedPrompt()` gĂ©nĂšre un rĂ©sumĂ© limitĂ© Ă  300 entrĂ©es -- Mais c'est toujours massif et non-pertinent - -## Solution : Prompt Contextuel Dynamique - -### StratĂ©gie - -Au lieu d'envoyer tout le lexique, on va : - -1. **Analyser le texte français** → extraire les mots-clĂ©s -2. **Chercher dans le lexique** → trouver uniquement les entrĂ©es pertinentes -3. **GĂ©nĂ©rer un prompt minimal** → inclure seulement le vocabulaire nĂ©cessaire -4. **Ajouter du contexte sĂ©mantique** → inclure des termes liĂ©s (synonymes, domaines connexes) - ---- - -## Plan d'ImplĂ©mentation DĂ©taillĂ© - -### **Phase 1 : Extraction de Contexte** - -**Fichier** : `ConfluentTranslator/contextAnalyzer.js` (nouveau) - -**FonctionnalitĂ©s** : -```javascript -// 1. Tokenizer simple français -function tokenizeFrench(text) - → Extraire les mots (lowercase, sans ponctuation) - -// 2. Recherche dans le lexique -function findRelevantEntries(words, lexique) - → Chercher correspondances exactes - → Chercher correspondances partielles (racines, lemmes) - → Score de pertinence - -// 3. Expansion sĂ©mantique -function expandContext(foundEntries, lexique) - → Ajouter synonymes - → Ajouter mots du mĂȘme domaine - → Limiter Ă  N entrĂ©es max (ex: 50) -``` - -**Exemple** : -``` -Input: "L'enfant voit l'eau" -→ Mots: ["enfant", "voit", "eau"] -→ Trouve: naki, mira, ura -→ Expand: + voir/regarder/observer, + riviĂšre/source -→ RĂ©sultat: 8-10 entrĂ©es au lieu de 516 -``` - ---- - -### **Phase 2 : GĂ©nĂ©rateur de Prompt Contextuel** - -**Fichier** : `ConfluentTranslator/promptBuilder.js` (nouveau) - -**FonctionnalitĂ©s** : -```javascript -// 1. Template de base (rules + syntaxe) -function getBasePrompt(variant) - → Phonologie, syntaxe, liaisons sacrĂ©es - → SANS le lexique massif - -// 2. Injection de vocabulaire ciblĂ© -function injectRelevantVocabulary(basePrompt, entries) - → Format compact et organisĂ© - → RegroupĂ© par domaine - -// 3. GĂ©nĂ©ration finale -function buildContextualPrompt(text, variant, lexique) - → Analyse contexte - → GĂ©nĂšre prompt minimal -``` - -**Structure du prompt** : -``` -[RÈGLES DE BASE - fixe, ~200 tokens] - -# VOCABULAIRE PERTINENT POUR CETTE TRADUCTION - -## Racines nĂ©cessaires -- naki (enfant) [racine standard] -- mira (voir) [verbe] -- ura (eau) [racine sacrĂ©e] - -## Termes liĂ©s -- aska (libre) [souvent utilisĂ© avec] -- sili (regard) [domaine: vision] - -[EXEMPLES - fixe, ~100 tokens] -``` - ---- - -### **Phase 3 : IntĂ©gration dans l'API** - -**Fichier** : `ConfluentTranslator/server.js` (modifier) - -**Modifications** : - -```javascript -// Importer nouveaux modules -const { analyzeContext } = require('./contextAnalyzer'); -const { buildContextualPrompt } = require('./promptBuilder'); - -// Modifier /translate endpoint -app.post('/translate', async (req, res) => { - const { text, target, provider, model, useLexique = true } = req.body; - - const variant = target === 'proto' ? 'proto' : 'ancien'; - - // NOUVEAU : GĂ©nĂ©ration contextuelle - const systemPrompt = useLexique - ? buildContextualPrompt(text, variant, lexiques[variant]) - : getBasePrompt(variant); - - // Le reste identique... -}); -``` - ---- - -### **Phase 4 : Optimisations AvancĂ©es** - -**Cache intelligent** : -```javascript -// ConfluentTranslator/promptCache.js -class PromptCache { - // Cache les prompts gĂ©nĂ©rĂ©s par hash du texte - // Évite de rĂ©gĂ©nĂ©rer pour phrases similaires -} -``` - -**Scoring sĂ©mantique** : -```javascript -// Utiliser word embeddings ou TF-IDF -// Pour trouver termes vraiment pertinents -function semanticScore(word, lexiqueEntry) { - // Retourne 0-1 -} -``` - ---- - -## BĂ©nĂ©fices Attendus - -| MĂ©trique | Avant | AprĂšs | Gain | -|----------|-------|-------|------| -| Tokens prompt | ~5000 | ~800 | **84%** | -| CoĂ»t par requĂȘte | $0.005 | $0.001 | **80%** | -| Pertinence | Faible | ÉlevĂ©e | ++ | -| Latence | Moyenne | Basse | + | - ---- - -## Ordre d'ImplĂ©mentation VALIDÉ - -### Phase 1 : Backend (Contexte & Prompt) -1. ✅ **CrĂ©er `contextAnalyzer.js`** - - Tokenizer français - - Recherche avec scoring - - Calcul dynamique max entrĂ©es (selon longueur) - - Expansion niveau 1 (modulaire pour futur) - - Fallback racines - -2. ✅ **CrĂ©er `promptBuilder.js`** - - Templates de base (sans lexique massif) - - Injection vocabulaire ciblĂ© - - GĂ©nĂ©ration fallback racines - - Formatage optimisĂ© - -3. ✅ **Modifier `server.js`** - - IntĂ©grer contextAnalyzer - - IntĂ©grer promptBuilder - - GĂ©nĂ©rer mĂ©tadonnĂ©es Layer 2 - - Parser rĂ©ponse LLM pour Layer 3 - - Retourner structure 3 layers - -### Phase 2 : Frontend (UI 3 Layers) -4. ✅ **Refonte UI - Structure HTML** - - Container Layer 1 (toujours visible) - - Container Layer 2 (collapsible) - - Container Layer 3 (collapsible) - -5. ✅ **JavaScript - Logique d'affichage** - - Toggle expand/collapse - - Affichage formatĂ© des mĂ©tadonnĂ©es - - Calcul tokens Ă©conomisĂ©s - -6. ✅ **CSS - Design responsive** - - Style des 3 layers - - Animations collapse/expand - - Indicateurs visuels - -### Phase 3 : Tests & Validation -7. ✅ **Tests unitaires** - - Tokenizer - - Scoring - - Calcul dynamique limites - -8. ✅ **Tests d'intĂ©gration** - - Cas simples, complexes, longs - - Fallback - - QualitĂ© traduction - -### Phase 4 : Optimisations (Optionnel - V2) -9. âšȘ **Cache intelligent** (si besoin de perf) -10. âšȘ **Metrics & Analytics** (tracking usage) -11. âšȘ **Expansion niveau 2+** (pour Confluent classique) - ---- - -## Configuration VALIDÉE - -### ParamĂštres de base -- **Max entrĂ©es par requĂȘte** : **VARIABLE selon longueur du texte** - - Phrases courtes (< 20 mots) : ~30 entrĂ©es - - Phrases moyennes (20-50 mots) : ~50 entrĂ©es - - Textes longs (> 50 mots) : jusqu'Ă  100 entrĂ©es - -- **Expansion sĂ©mantique** : **Niveau 1 (strict) - MODULAIRE** - - Pour Proto-Confluent et Ancien Confluent : synonymes directs uniquement - - Architecture prĂ©parĂ©e pour expansion future (Confluent classique avec niveau 2-3) - -- **Fallback** : **Envoyer TOUTES LES RACINES + instruction de composition** - - Si aucun terme trouvĂ© dans le lexique - - Inclure toutes les racines sacrĂ©es + racines standards - - Instruction au LLM : "Composer Ă  partir des racines disponibles" - -### PrioritĂ©s de recherche -1. Correspondance exacte (score: 1.0) -2. Synonymes français directs (score: 0.9) -3. **[FUTUR - Niveau 2+]** MĂȘme domaine sĂ©mantique (score: 0.7) -4. **[FUTUR - Niveau 2+]** Racine partagĂ©e (score: 0.5) -5. **[FUTUR]** Termes frĂ©quents gĂ©nĂ©riques (score: 0.3) - ---- - -## Architecture UI : 3 Layers VALIDÉE - -L'interface affichera la traduction en **3 couches progressives** : - -### **LAYER 1 : TRADUCTION (Toujours visible)** -RĂ©sultat principal, directement affichĂ©. - -``` -┌─────────────────────────────────────────┐ -│ TRADUCTION │ -│ ─────────────────────────────────────── │ -│ va naki vo ura miraku │ -└─────────────────────────────────────────┘ -``` - -### **LAYER 2 : CONTEXTE (Expandable - COT hors LLM)** -Contexte extrait AVANT l'appel au LLM. - -``` -┌─────────────────────────────────────────┐ -│ 📚 CONTEXTE LEXICAL (Cliquer pour voir) │ -│ ─────────────────────────────────────── │ -│ Mots trouvĂ©s dans le lexique: │ -│ ‱ enfant → naki (racine standard) │ -│ ‱ voir → mira (verbe) │ -│ ‱ eau → ura (racine sacrĂ©e) │ -│ │ -│ 📊 Optimisation: │ -│ ‱ Tokens Ă©conomisĂ©s: 4200 (-84%) │ -│ ‱ EntrĂ©es utilisĂ©es: 8/516 │ -│ ‱ EntrĂ©es envoyĂ©es au LLM: 8 │ -└─────────────────────────────────────────┘ -``` - -### **LAYER 3 : COMMENTAIRES LLM (Expandable)** -Explications gĂ©nĂ©rĂ©es par le LLM. - -``` -┌─────────────────────────────────────────┐ -│ 💡 EXPLICATIONS (Cliquer pour voir) │ -│ ─────────────────────────────────────── │ -│ 🔧 DĂ©composition: │ -│ va naki = SUJET enfant │ -│ vo ura = OBJET eau │ -│ miraku = voir (prĂ©sent -u) │ -│ │ -│ đŸ› ïž Mots crĂ©Ă©s/composĂ©s: │ -│ (aucun pour cette phrase) │ -│ │ -│ 📝 Notes linguistiques: │ -│ Ordre SOV respectĂ©, particules │ -│ correctes, conjugaison prĂ©sent. │ -└─────────────────────────────────────────┘ -``` - -### Logique d'affichage -- **Layer 1** : Toujours affichĂ©, focus principal -- **Layer 2** : Collapsed par dĂ©faut, clic pour expand -- **Layer 3** : Collapsed par dĂ©faut, clic pour expand -- Les layers sont **indĂ©pendants** (on peut ouvrir 2, 3, les deux, ou aucun) - ---- - -## Cas d'Usage Typiques - -### Cas 1 : Phrase simple (< 20 mots) -**Input** : "L'enfant voit l'eau" -**Longueur** : 4 mots → Limite: 30 entrĂ©es -**Contexte extrait** : enfant (naki), voir (mira), eau (ura) -**Expansion** : voir/regarder (synonymes directs uniquement - niveau 1) -**Total** : ~8 entrĂ©es envoyĂ©es - -### Cas 2 : Phrase complexe avec castes (20-50 mots) -**Input** : "Les Enfants des Échos transmettent la mĂ©moire sacrĂ©e aux jeunes gĂ©nĂ©rations dans les halls des serments" -**Longueur** : 16 mots → Limite: 50 entrĂ©es -**Contexte extrait** : Nakukeko, transmettre (kisu), mĂ©moire (mori), sacrĂ© (asa), jeune, gĂ©nĂ©ration, halls (Talusavu) -**Expansion** : Ă©cho (keko), enfant (naki), synonymes directs -**Total** : ~20 entrĂ©es envoyĂ©es - -### Cas 3 : Texte narratif long (> 50 mots) -**Input** : Paragraphe de 100+ mots -**Longueur** : 100 mots → Limite: 100 entrĂ©es -**StratĂ©gie** : -- Extraire tous les mots-clĂ©s uniques -- Chercher correspondances exactes + synonymes directs -- Limiter Ă  top 100 termes par pertinence (score) -**Total** : 100 entrĂ©es max - -### Cas 4 : Mot inconnu (Fallback) -**Input** : "Le scientifique utilise un microscope" -**Longueur** : 5 mots → Limite: 30 entrĂ©es -**Contexte trouvĂ©** : (aucun - mots modernes non dans le lexique) -**Fallback activĂ©** : -- Envoyer TOUTES les racines sacrĂ©es (15) -- Envoyer TOUTES les racines standards (52) -- Total: 67 racines de base -- Instruction LLM : "Compose Ă  partir des racines disponibles" -**Total** : 67 entrĂ©es (racines uniquement) - ---- - -## Architecture Technique (Mise Ă  jour avec 3 Layers) - -``` -┌─────────────────┐ -│ User Input │ -│ (français) │ -└────────┬────────┘ - │ - â–Œ -┌──────────────────────────────────────────┐ -│ contextAnalyzer.js │ -│ - tokenizeFrench() │ -│ - calculateMaxEntries(wordCount) │ ← NOUVEAU: calcul dynamique -│ - findRelevantEntries(expansionLevel=1) │ ← Niveau modulaire -│ - expandContext() [LEVEL 1 only] │ -└────────┬─────────────────────────────────┘ - │ - │ [context metadata for Layer 2] - │ - words found - │ - entries used - │ - tokens saved - â–Œ -┌──────────────────────────────────────────┐ -│ promptBuilder.js │ -│ - getBasePrompt(variant) │ -│ - getRootsFallback() [if needed] │ ← NOUVEAU: fallback racines -│ - injectVocabulary(entries) │ -│ - buildContextualPrompt() │ -└────────┬─────────────────────────────────┘ - │ - │ [optimized prompt + metadata] - â–Œ -┌──────────────────────────────────────────┐ -│ server.js - /translate endpoint │ -│ - Call contextAnalyzer │ -│ - Build prompt │ -│ - Store Layer 2 data (COT) │ ← NOUVEAU: mĂ©tadonnĂ©es -│ - Call LLM API │ -└────────┬─────────────────────────────────┘ - │ - │ [prompt with minimal context] - â–Œ -┌──────────────────────────────────────────┐ -│ LLM API (Claude/GPT) │ -│ - Receive optimized prompt │ -│ - Generate translation │ -│ - Generate explanations │ -└────────┬─────────────────────────────────┘ - │ - │ [LLM response] - â–Œ -┌──────────────────────────────────────────┐ -│ Response Parser │ -│ - Extract translation (Layer 1) │ -│ - Extract explanations (Layer 3) │ -│ - Combine with context metadata (L2) │ -└────────┬─────────────────────────────────┘ - │ - â–Œ -┌──────────────────────────────────────────┐ -│ JSON Response to Frontend │ -│ { │ -│ layer1: { translation: "..." }, │ -│ layer2: { │ -│ wordsFound: [...], │ -│ entriesUsed: 8, │ -│ tokensSaved: 4200 │ -│ }, │ -│ layer3: { │ -│ decomposition: "...", │ -│ wordsCreated: [...], │ -│ notes: "..." │ -│ } │ -│ } │ -└────────┬─────────────────────────────────┘ - │ - â–Œ -┌──────────────────────────────────────────┐ -│ Frontend UI (3 Layers) │ -│ ┌────────────────────────────────────┐ │ -│ │ Layer 1: Translation (visible) │ │ -│ └────────────────────────────────────┘ │ -│ ┌────────────────────────────────────┐ │ -│ │ Layer 2: Context (collapsible) │ │ -│ └────────────────────────────────────┘ │ -│ ┌────────────────────────────────────┐ │ -│ │ Layer 3: Explanations (collapsible)│ │ -│ └────────────────────────────────────┘ │ -└──────────────────────────────────────────┘ -``` - ---- - -## Tests de Validation - -### Test 1 : RĂ©duction de tokens -```javascript -// Mesurer avant/aprĂšs -const before = countTokens(oldPrompt); -const after = countTokens(newPrompt); -assert(after < before * 0.2); // RĂ©duction de 80% -``` - -### Test 2 : QualitĂ© de traduction -```javascript -// Comparer qualitĂ© avec plusieurs phrases -const testCases = [ - "L'enfant voit l'eau", - "Les Passes-bien portent les biens", - "Le faucon chasse dans le ciel" -]; -// Valider que traductions restent correctes -``` - -### Test 3 : Performance -```javascript -// Mesurer temps de gĂ©nĂ©ration de prompt -const start = Date.now(); -const prompt = buildContextualPrompt(text, 'ancien', lexique); -const duration = Date.now() - start; -assert(duration < 100); // < 100ms -``` - ---- - -## MĂ©triques de SuccĂšs - -- ✅ **RĂ©duction tokens** : > 70% -- ✅ **QualitĂ© traduction** : identique ou meilleure -- ✅ **Temps gĂ©nĂ©ration prompt** : < 100ms -- ✅ **Taux de cache hit** : > 30% (si cache activĂ©) -- ✅ **Satisfaction utilisateur** : retours positifs - ---- - -## Prochaines ItĂ©rations (V2, V3...) - -### V2 : Intelligence contextuelle -- Apprentissage des patterns frĂ©quents -- Suggestions de vocabulaire manquant -- DĂ©tection automatique de nouveaux termes Ă  ajouter au lexique - -### V3 : Optimisations ML -- Embeddings sĂ©mantiques pour meilleure expansion -- PrĂ©diction de termes nĂ©cessaires avant recherche -- Compression intelligente du prompt - -### V4 : Multi-langue -- Support Proto-Confluent ↔ Ancien Confluent -- Traduction bidirectionnelle Confluent → Français -- DĂ©tection automatique de variante diff --git a/docs/PROMPT_FORMULES_RITUELLES.md b/docs/PROMPT_FORMULES_RITUELLES.md deleted file mode 100644 index 2240169..0000000 --- a/docs/PROMPT_FORMULES_RITUELLES.md +++ /dev/null @@ -1,281 +0,0 @@ -# Prompt pour gĂ©nĂ©rer des formules rituelles en Confluent - -Tu es un expert linguiste spĂ©cialisĂ© dans la langue **Confluent**, une langue construite pour la Civilisation de la Confluence (projet JDR). - -## Ta mission - -CrĂ©er des **formules rituelles** authentiques en Confluent, courtes et mĂ©morables, qui respectent parfaitement la grammaire et reflĂštent la culture. - ---- - -## SYSTÈME LINGUISTIQUE - -### Phonologie -- **Consonnes:** b, k, l, m, n, p, s, t, v, z -- **Voyelles:** a, e, i, o, u -- **Structure:** Toutes les racines finissent par CV (consonne + voyelle) - -### Structure de phrase (SOV) -``` -[Circonstants] [Sujet] [Objet] [NĂ©gation] Verbe Conjugateur [Mode] [Question] -``` - -### Particules de cas -- **va** = sujet -- **vo** = objet direct -- **vi** = vers -- **ve** = depuis -- **no** = dans, Ă  (lieu) - -### Connecteurs logiques -- **ti** = et -- **bo** = mais -- **me** = si -- **ne** = alors - -### NĂ©gation -- **zo** = ne...pas -- **zom** = jamais - -### Conjugateurs (aprĂšs le verbe) -- **u** = prĂ©sent -- **at** = passĂ© vĂ©cu -- **ait** = passĂ© ancestral -- **eom** = Ă©ternel, toujours vrai - -### Pronoms -- **miki** = je/moi -- **sinu** = tu/toi -- **tani** = il/elle/iel -- Pluriel: pronom + **su** (miki su = nous) - -### Verbes clĂ©s (CVCVC) -- **mirak** = voir, observer -- **vosak** = dire, parler -- **sekam** = savoir, connaĂźtre -- **kisun** = transmettre -- **morik** = mĂ©moriser -- **tekis** = aller -- **umiak** = mĂ©diter - -### Racines importantes -- **sili** = regard, vision -- **aska** = libre, libertĂ© -- **ura** = eau, fluide -- **kota** = union, confluence -- **aita** = ancĂȘtre -- **ora** = aurore -- **umi** = esprit, souffle vital -- **asa** = sacrĂ© -- **mori** = mĂ©moire -- **veri** = vrai, vĂ©ritĂ© -- **kori** = cƓur - -### Liaisons sacrĂ©es (entre racines) -- **-i-** = agent actif (celui qui fait) -- **-u-** = appartenance (de, appartenant Ă ) -- **-a-** = avec (ensemble) -- **-aa-** = mĂ©lange, confluence -- **-ii-** = essence (celui qui EST) - ---- - -## CULTURE DE LA CONFLUENCE - -### Valeurs centrales -1. **L'observation** - Regarder avant d'agir -2. **La transmission** - Le savoir doit ĂȘtre partagĂ© -3. **La mĂ©moire** - Les ancĂȘtres vivent par le souvenir -4. **La confluence** - Union enrichit (comme les eaux qui se mĂȘlent) -5. **Le regard partagĂ©** - Contact visuel scelle les accords - -### Rituels importants -- **Rituel du Regard PartagĂ©** - Contact visuel pour serments -- **Vigile Lunaire** - Cycle bimensuel -- **PĂšlerinage au Gouffre Humide** - Rite de passage - -### Symboles -- **Le regard/les yeux** = vĂ©ritĂ©, observation -- **La confluence** = union, force -- **L'aurore** = naissance, promesse divine -- **Les Regards-Libres** (grues) = voir au-delĂ , libertĂ© - -### Castes -- **Oraumi** (Voix de l'Aurore) - chamans suprĂȘmes -- **Aliaska** (Ailes-Grises) - dresseurs de grues -- **Akoazana** (Faucons Chasseurs) - Ă©lite militaire -- **Nakuura** (Enfants du Courant) - pĂȘcheurs -- **Nakukeko** (Enfants des Échos) - mineurs, artisans -- **Takitosa** (Passes-bien) - marchands - ---- - -## FORMULES À CRÉER - -### 1. Salutations - -**Formelle (entre castes diffĂ©rentes):** -- Courte (2-4 mots) -- Mention du regard ou de l'observation -- Respectueuse - -**Informelle (entre pairs):** -- Plus courte (1-2 mots) -- Chaleureuse - -**RĂ©vĂ©rencielle (vers Voix de l'Aurore):** -- Plus longue (3-5 mots) -- Mention de l'aurore ou du sacrĂ© - -### 2. Rituel du Regard PartagĂ© - -**Ouverture:** -- Invitation au contact visuel -- Solennel - -**Validation/ClĂŽture:** -- Scelle l'accord -- "Qu'il soit vu" ou "C'est observĂ©" - -**Serment:** -- Formule d'engagement -- Mentionne la vĂ©ritĂ© et le regard - -### 3. BĂ©nĂ©dictions - -**Naissance:** -- Souhaite observation et sagesse -- Courte et douce - -**Voyage:** -- Protection en chemin -- Retour sĂ»r - -**Avant Ă©preuve/danger:** -- Courage -- Que le regard reste clair - -### 4. Formules de mĂ©moire - -**Honorer les ancĂȘtres:** -- "Qu'ils ne soient pas oubliĂ©s" -- Mention de la mĂ©moire - -**Invocation des Premiers AncĂȘtres:** -- Plus solennelle -- PassĂ© ancestral (ait/amat) - -**"Que cela ne soit pas oubliĂ©":** -- Formule courte et marquante -- Pour moments importants - -### 5. Transmission de savoir - -**Ouverture d'enseignement:** -- "J'offre ce que j'ai vu" -- Humble - -**Acceptation:** -- "Je reçois avec attention" - -**Remerciement:** -- Gratitude pour transmission - -### 6. Mort et deuil - -**Au moment du dĂ©cĂšs:** -- L'esprit part -- Retour aux ancĂȘtres - -**Pour guider l'esprit:** -- Vers les ancĂȘtres -- Pas de peur - -**Consolation:** -- Il/elle vit dans la mĂ©moire -- Le regard reste - -### 7. Union/Confluence (mariage) - -**Serment d'union:** -- "Comme les eaux se mĂȘlent" -- Utiliser liaison -aa- (mĂ©lange) -- RĂ©fĂ©rence Ă  la confluence - ---- - -## INSTRUCTIONS - -Pour chaque formule: - -1. **Écris en Confluent** d'abord -2. **DĂ©compose** mot par mot avec glose -3. **Traduis** en français littĂ©ral -4. **Explique** le sens culturel -5. **Indique** le contexte d'usage - -### Format attendu - -``` -### [Nom de la formule] - -**Confluent:** [formule en confluent] - -**Glose:** -[mot 1] [fonction] [mot 2] [fonction] verbe conjugateur -= traduction littĂ©rale mot-Ă -mot - -**Traduction:** [traduction naturelle en français] - -**Usage:** [quand et comment l'utiliser] - -**Notes culturelles:** [signification profonde] -``` - -### Exemple - -``` -### Salutation formelle - -**Confluent:** Sil-u-veri va miki mirak u - -**Glose:** -sil-u-veri (regard-de-vĂ©ritĂ©) va (SUJET) miki (je) mirak (voir) u (PRÉSENT) -= "regard de vĂ©ritĂ© je vois" - -**Traduction:** "Je vois avec un regard vrai" / "Mon regard est sincĂšre" - -**Usage:** Salutation respectueuse entre castes diffĂ©rentes, implique honnĂȘtetĂ© - -**Notes culturelles:** Affirme l'intention d'observer avec vĂ©ritĂ©, valeur centrale -``` - ---- - -## CONTRAINTES IMPORTANTES - -- ✅ Respecte PARFAITEMENT la grammaire (ordre SOV, particules, conjugaison) -- ✅ Utilise uniquement les racines et verbes dĂ©finis -- ✅ Phrases courtes (3-8 mots max pour ĂȘtre mĂ©morables) -- ✅ SonoritĂ© finno-basque (fluide, pas trop de consonnes) -- ✅ CohĂ©rence culturelle (valeurs, symboles, rituels) -- ❌ Pas de nĂ©ologismes - utilise le vocabulaire existant -- ❌ Pas de structures grammaticales inventĂ©es -- ❌ Pas de formules trop longues ou complexes - ---- - -## COMMENCE PAR - -GĂ©nĂšre les **7 catĂ©gories** de formules rituelles dans l'ordre: -1. Salutations (3 variantes) -2. Regard PartagĂ© (3 formules) -3. BĂ©nĂ©dictions (3 types) -4. MĂ©moire (3 formules) -5. Transmission (3 formules) -6. Mort et deuil (3 formules) -7. Union/Confluence (1 formule principale) - -**Total:** ~19-20 formules rituelles prĂȘtes pour le JDR. - -Vas-y, crĂ©e des formules authentiques et belles! diff --git a/docs/RACINES_VERBES_FRANCAIS.md b/docs/RACINES_VERBES_FRANCAIS.md deleted file mode 100644 index 57c6a9b..0000000 --- a/docs/RACINES_VERBES_FRANCAIS.md +++ /dev/null @@ -1,395 +0,0 @@ -# Racines françaises des verbes - Lexique Confluent - -Ce document liste les racines françaises optimales pour chaque verbe du lexique ancien-confluent. - -## Format - -Pour chaque verbe : -- **Racine** : dĂ©nominateur commun optimal couvrant la majoritĂ© des conjugaisons -- **Couvre** : exemples de formes couvertes par la racine -- **Exceptions** : formes avec radical diffĂ©rent Ă  mettre dans synonymes_fr - ---- - -## Verbes d'observation et perception - -### voir -- **Racine** : `"voi"` -- **Couvre** : vois, voit, voient, voyons, voyez, voyais, voyait, voyions, voyiez, voyaient, voyant, verrai, verras, verra, verrons, verrez, verront -- **Exceptions** : "vu" (participe passĂ©), "vois" (impĂ©ratif singulier), "voyez" (impĂ©ratif pluriel) -- **Note** : Verbe trĂšs irrĂ©gulier, mais "voi" + "voy" couvrent 90% des formes. Les formes en "v-" seules (vu, vis) et "verr-" (futur) sont exceptionnelles. - -### observer -- **Racine** : `"observ"` -- **Couvre** : observe, observes, observent, observons, observez, observais, observait, observions, observiez, observaient, observerai, observeras, observera, observerons, observerez, observeront, observant, observĂ©, observĂ©e, observĂ©s, observĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### regarder -- **Racine** : `"regard"` -- **Couvre** : regarde, regardes, regardent, regardons, regardez, regardais, regardait, regardions, regardiez, regardaient, regarderai, regarderas, regardera, regarderons, regarderez, regarderont, regardant, regardĂ©, regardĂ©e, regardĂ©s, regardĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### Ă©couter -- **Racine** : `"Ă©cout"` -- **Couvre** : Ă©coute, Ă©coutes, Ă©coutent, Ă©coutons, Ă©coutez, Ă©coutais, Ă©coutait, Ă©coutions, Ă©coutiez, Ă©coutaient, Ă©couterai, Ă©couteras, Ă©coutera, Ă©couterons, Ă©couterez, Ă©couteront, Ă©coutant, Ă©coutĂ©, Ă©coutĂ©e, Ă©coutĂ©s, Ă©coutĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## Verbes de mouvement - -### aller -- **Racine** : `null` -- **Couvre** : N/A -- **Exceptions** : Verbe totalement irrĂ©gulier avec 4 radicaux distincts : "v-" (vais, vas, va, vont), "all-" (allons, allez, allais, allait, allions, alliez, allaient, allant, allĂ©), "i-" (irai, iras, ira, irons, irez, iront), "aill-" (aille, ailles, aillent, aillions, ailliez) -- **Note** : Stocker toutes les formes dans synonymes_fr - -### fuir -- **Racine** : `"fui"` -- **Couvre** : fuis, fuit, fuyons, fuyez, fuyais, fuyait, fuyions, fuyiez, fuyaient, fuirai, fuiras, fuira, fuirons, fuirez, fuiront, fuyant, fui, fuie, fuis, fuies -- **Exceptions** : "fuient" et "fuyent" (prĂ©sent 3e pl.) - doublon "fui" vs "fuy" -- **Note** : "fui" couvre prĂ©sent singulier, futur, participe passĂ©. "fuy" pour pluriel/imparfait. Racine "fui" est majoritaire. - ---- - -## Verbes de don et Ă©change - -### donner -- **Racine** : `"donn"` -- **Couvre** : donne, donnes, donnent, donnons, donnez, donnais, donnait, donnions, donniez, donnaient, donnerai, donneras, donnera, donnerons, donnerez, donneront, donnant, donnĂ©, donnĂ©e, donnĂ©s, donnĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### prendre -- **Racine** : `"pren"` -- **Couvre** : prends, prend, prenons, prenez, prenais, prenait, prenions, preniez, prenaient, prendrai, prendras, prendra, prendrons, prendrez, prendront, prenant -- **Exceptions** : "prennent" (prĂ©sent 3e pl.), "pris" (participe passĂ©), "prisse" (subjonctif imparfait) -- **Note** : "pren" couvre 80% des formes. "prenn" et "pri" sont minoritaires. - ---- - -## Verbes de crĂ©ation et fabrication - -### faire -- **Racine** : `"fai"` -- **Couvre** : fais, fait, faisons, faites, faisais, faisait, faisions, faisiez, faisaient, faisant -- **Exceptions** : "font" (prĂ©sent 3e pl.), "ferai, feras, fera, ferons, ferez, feront" (futur) -- **Note** : Verbe irrĂ©gulier avec 3 radicaux : "fai-", "f-" (font), "fer-" (futur). "fai" est majoritaire. - -### crĂ©er -- **Racine** : `"crĂ©"` -- **Couvre** : crĂ©e, crĂ©es, crĂ©ent, crĂ©ons, crĂ©ez, crĂ©ais, crĂ©ait, crĂ©ions, crĂ©iez, crĂ©aient, crĂ©erai, crĂ©eras, crĂ©era, crĂ©erons, crĂ©erez, crĂ©eront, crĂ©ant, crĂ©Ă©, crĂ©Ă©e, crĂ©Ă©s, crĂ©Ă©es -- **Exceptions** : aucune (verbe rĂ©gulier en -er) - -### construire -- **Racine** : `"construi"` -- **Couvre** : construis, construit, construisons, construisez, construisais, construisait, construisions, construisiez, construisaient, construirai, construiras, construira, construirons, construirez, construiront, construisant -- **Exceptions** : "construisent" (prĂ©sent 3e pl.), "construit" (participe passĂ©) -- **Note** : Verbe en -uire, racine stable "construi" - -### assembler -- **Racine** : `"assembl"` -- **Couvre** : assemble, assembles, assemblent, assemblons, assemblez, assemblais, assemblait, assemblions, assembliez, assemblaient, assemblerai, assembleras, assemblera, assemblerons, assemblerez, assembleront, assemblant, assemblĂ©, assemblĂ©e, assemblĂ©s, assemblĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## Verbes de communication - -### dire -- **Racine** : `"di"` -- **Couvre** : dis, dit, disons, disais, disait, disions, disiez, disaient, dirai, diras, dira, dirons, direz, diront, disant -- **Exceptions** : "dites" (prĂ©sent 2e pl., pas "disez"), "dit" (participe passĂ©) -- **Note** : Verbe irrĂ©gulier mais racine "di" stable sauf "dites" - -### parler -- **Racine** : `"parl"` -- **Couvre** : parle, parles, parlent, parlons, parlez, parlais, parlait, parlions, parliez, parlaient, parlerai, parleras, parlera, parlerons, parlerez, parleront, parlant, parlĂ©, parlĂ©e, parlĂ©s, parlĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## Verbes de connaissance et apprentissage - -### savoir -- **Racine** : `"sav"` -- **Couvre** : sais, sait, savons, savez, savais, savait, savions, saviez, savaient, saurai, sauras, saura, saurons, saurez, sauront, sachant -- **Exceptions** : "savent" (prĂ©sent 3e pl.), "su" (participe passĂ©), "sache, saches, sachent, sachions, sachiez" (subjonctif) -- **Note** : Verbe irrĂ©gulier avec 3 radicaux : "sav-", "sach-", "saur-" (futur), "su" (pp). "sav" est majoritaire. - -### connaĂźtre -- **Racine** : `"connaĂź"` -- **Couvre** : connais, connaĂźt, connaissons, connaissez, connaissais, connaissait, connaissions, connaissiez, connaissaient, connaĂźtrai, connaĂźtras, connaĂźtra, connaĂźtrons, connaĂźtrez, connaĂźtront, connaissant -- **Exceptions** : "connaissent" (prĂ©sent 3e pl.), "connu" (participe passĂ©) -- **Note** : Racine "connaĂź" couvre la majoritĂ©, variante "connaiss" au prĂ©sent pluriel et imparfait - -### apprendre -- **Racine** : `"appren"` -- **Couvre** : apprends, apprend, apprenons, apprenez, apprenais, apprenait, apprenions, appreniez, apprenaient, apprendrai, apprendras, apprendra, apprendrons, apprendrez, apprendront, apprenant -- **Exceptions** : "apprennent" (prĂ©sent 3e pl.), "appris" (participe passĂ©) -- **Note** : MĂȘme structure que "prendre" - -### transmettre -- **Racine** : `"transmet"` -- **Couvre** : transmets, transmet, transmettons, transmettez, transmettais, transmettait, transmettions, transmettiez, transmettaient, transmettrai, transmettras, transmettra, transmettrons, transmettrez, transmettront, transmettant -- **Exceptions** : "transmettent" (prĂ©sent 3e pl.), "transmis" (participe passĂ©) -- **Note** : Verbe en -mettre, racine stable "transmet" - -### enseigner -- **Racine** : `"enseign"` -- **Couvre** : enseigne, enseignes, enseignent, enseignons, enseignez, enseignais, enseignait, enseignions, enseigniez, enseignaient, enseignerai, enseigneras, enseignera, enseignerons, enseignerez, enseigneront, enseignant, enseignĂ©, enseignĂ©e, enseignĂ©s, enseignĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### Ă©tudier -- **Racine** : `"Ă©tudi"` -- **Couvre** : Ă©tudie, Ă©tudies, Ă©tudient, Ă©tudions, Ă©tudiez, Ă©tudiais, Ă©tudiait, Ă©tudiions, Ă©tudiiez, Ă©tudiaient, Ă©tudierai, Ă©tudieras, Ă©tudiera, Ă©tudierons, Ă©tudierez, Ă©tudieront, Ă©tudiant, Ă©tudiĂ©, Ă©tudiĂ©e, Ă©tudiĂ©s, Ă©tudiĂ©es -- **Exceptions** : aucune (verbe rĂ©gulier en -ier) - -### mĂ©moriser -- **Racine** : `"mĂ©moris"` -- **Couvre** : mĂ©morise, mĂ©morises, mĂ©morisent, mĂ©morisons, mĂ©morisez, mĂ©morisais, mĂ©morisait, mĂ©morisions, mĂ©morisiez, mĂ©morisaient, mĂ©moriserai, mĂ©moriseras, mĂ©morisera, mĂ©moriserons, mĂ©moriserez, mĂ©moriseront, mĂ©morisant, mĂ©morisĂ©, mĂ©morisĂ©e, mĂ©morisĂ©s, mĂ©morisĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### dĂ©couvrir -- **Racine** : `"dĂ©couvr"` -- **Couvre** : dĂ©couvre, dĂ©couvres, dĂ©couvrent, dĂ©couvrons, dĂ©couvrez, dĂ©couvrais, dĂ©couvrait, dĂ©couvrions, dĂ©couvriez, dĂ©couvraient, dĂ©couvrirai, dĂ©couvriras, dĂ©couvrira, dĂ©couvrirons, dĂ©couvrirez, dĂ©couvriront, dĂ©couvrant -- **Exceptions** : "dĂ©couvert" (participe passĂ©) -- **Note** : Verbe en -vrir, racine stable "dĂ©couvr" - -### explorer -- **Racine** : `"explor"` -- **Couvre** : explore, explores, explorent, explorons, explorez, explorais, explorait, explorions, exploriez, exploraient, explorerai, exploreras, explorera, explorerons, explorerez, exploreront, explorant, explorĂ©, explorĂ©e, explorĂ©s, explorĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### interprĂ©ter -- **Racine** : `"interprĂšt"` -- **Couvre** : interprĂšte, interprĂštes, interprĂštent, interprĂ©tons, interprĂ©tez, interprĂ©tais, interprĂ©tait, interprĂ©tions, interprĂ©tiez, interprĂ©taient, interprĂ©terai, interprĂ©teras, interprĂ©tera, interprĂ©terons, interprĂ©terez, interprĂ©teront, interprĂ©tant, interprĂ©tĂ©, interprĂ©tĂ©e, interprĂ©tĂ©s, interprĂ©tĂ©es -- **Exceptions** : variation "Ăš" vs "Ă©" selon les formes -- **Note** : Racine "interprĂšt" couvre la majoritĂ© des formes - ---- - -## Verbes d'action physique - -### garder -- **Racine** : `"gard"` -- **Couvre** : garde, gardes, gardent, gardons, gardez, gardais, gardait, gardions, gardiez, gardaient, garderai, garderas, gardera, garderons, garderez, garderont, gardant, gardĂ©, gardĂ©e, gardĂ©s, gardĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### protĂ©ger -- **Racine** : `"protĂšg"` -- **Couvre** : protĂšge, protĂšges, protĂšgent, protĂ©geons, protĂ©gez, protĂ©geais, protĂ©geait, protĂ©gions, protĂ©giez, protĂ©geaient, protĂ©gerai, protĂ©geras, protĂ©gera, protĂ©gerons, protĂ©gerez, protĂ©geront, protĂ©geant, protĂ©gĂ©, protĂ©gĂ©e, protĂ©gĂ©s, protĂ©gĂ©es -- **Exceptions** : variation "Ăš" vs "Ă©" selon les formes -- **Note** : Racine "protĂšg" majoritaire - -### porter -- **Racine** : `"port"` -- **Couvre** : porte, portes, portent, portons, portez, portais, portait, portions, portiez, portaient, porterai, porteras, portera, porterons, porterez, porteront, portant, portĂ©, portĂ©e, portĂ©s, portĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### transporter -- **Racine** : `"transport"` -- **Couvre** : transporte, transportes, transportent, transportons, transportez, transportais, transportait, transportions, transportiez, transportaient, transporterai, transporteras, transportera, transporterons, transporterez, transporteront, transportant, transportĂ©, transportĂ©e, transportĂ©s, transportĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### chasser -- **Racine** : `"chass"` -- **Couvre** : chasse, chasses, chassent, chassons, chassez, chassais, chassait, chassions, chassiez, chassaient, chasserai, chasseras, chassera, chasserons, chasserez, chasseront, chassant, chassĂ©, chassĂ©e, chassĂ©s, chassĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### traquer -- **Racine** : `"traqu"` -- **Couvre** : traque, traques, traquent, traquons, traquez, traquais, traquait, traquions, traquiez, traquaient, traquerai, traqueras, traquera, traquerons, traquerez, traqueront, traquant, traquĂ©, traquĂ©e, traquĂ©s, traquĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## Verbes spirituels et sacrĂ©s - -### mĂ©diter -- **Racine** : `"mĂ©dit"` -- **Couvre** : mĂ©dite, mĂ©dites, mĂ©ditent, mĂ©ditons, mĂ©ditez, mĂ©ditais, mĂ©ditait, mĂ©ditions, mĂ©ditiez, mĂ©ditaient, mĂ©diterai, mĂ©diteras, mĂ©ditera, mĂ©diterons, mĂ©diterez, mĂ©diteront, mĂ©ditant, mĂ©ditĂ©, mĂ©ditĂ©e, mĂ©ditĂ©s, mĂ©ditĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### prier -- **Racine** : `"pri"` -- **Couvre** : prie, pries, prient, prions, priez, priais, priait, priions, priiez, priaient, prierai, prieras, priera, prierons, prierez, prieront, priant, priĂ©, priĂ©e, priĂ©s, priĂ©es -- **Exceptions** : aucune (verbe rĂ©gulier en -ier) - -### invoquer -- **Racine** : `"invoqu"` -- **Couvre** : invoque, invoques, invoquent, invoquons, invoquez, invoquais, invoquait, invoquions, invoquiez, invoquaient, invoquerai, invoqueras, invoquera, invoquerons, invoquerez, invoqueront, invoquant, invoquĂ©, invoquĂ©e, invoquĂ©s, invoquĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### bĂ©nir -- **Racine** : `"bĂ©ni"` -- **Couvre** : bĂ©nis, bĂ©nit, bĂ©nissons, bĂ©nissez, bĂ©nissais, bĂ©nissait, bĂ©nissions, bĂ©nissiez, bĂ©nissaient, bĂ©nirai, bĂ©niras, bĂ©nira, bĂ©nirons, bĂ©nirez, bĂ©niront, bĂ©nissant -- **Exceptions** : "bĂ©nit" vs "bĂ©ni" (participes passĂ©s selon usage) -- **Note** : Verbe en -ir, racine "bĂ©ni" stable - -### communier -- **Racine** : `"communi"` -- **Couvre** : communie, communies, communient, communions, communiez, communiais, communiait, communiions, communiiez, communiaient, communierai, communieras, communiera, communierons, communierez, communieront, communiant, communiĂ©, communiĂ©e, communiĂ©s, communiĂ©es -- **Exceptions** : aucune (verbe rĂ©gulier en -ier) - -### mourir -- **Racine** : `"meur"` -- **Couvre** : meurs, meurt, mourons, mourez, mourais, mourait, mourions, mouriez, mouraient, mourrai, mourras, mourra, mourrons, mourrez, mourront, mourant -- **Exceptions** : "meurent" (prĂ©sent 3e pl.), "mort" (participe passĂ©) -- **Note** : Verbe irrĂ©gulier avec 3 radicaux : "meur-", "mour-", "mort". "meur" couvre singulier prĂ©sent. - ---- - -## Verbes artisanaux et crĂ©ation - -### graver -- **Racine** : `"grav"` -- **Couvre** : grave, graves, gravent, gravons, gravez, gravais, gravait, gravions, graviez, gravaient, graverai, graveras, gravera, graverons, graverez, graveront, gravant, gravĂ©, gravĂ©e, gravĂ©s, gravĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### sculpter -- **Racine** : `"sculpt"` -- **Couvre** : sculpte, sculptes, sculptent, sculptons, sculptez, sculptais, sculptait, sculptions, sculptiez, sculptaient, sculpterai, sculpteras, sculptera, sculpterons, sculpterez, sculpteront, sculptant, sculptĂ©, sculptĂ©e, sculptĂ©s, sculptĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### peindre -- **Racine** : `"pein"` -- **Couvre** : peins, peint, peignons, peignez, peignais, peignait, peignions, peigniez, peignaient, peindrai, peindras, peindra, peindrons, peindrez, peindront, peignant -- **Exceptions** : "peignent" (prĂ©sent 3e pl.), "peint" (participe passĂ©) -- **Note** : Verbe en -eindre, racine "pein" majoritaire, variante "peign" au pluriel/imparfait - -### creuser -- **Racine** : `"creus"` -- **Couvre** : creuse, creuses, creusent, creusons, creusez, creusais, creusait, creusions, creusiez, creusaient, creuserai, creuseras, creusera, creuserons, creuserez, creuseront, creusant, creusĂ©, creusĂ©e, creusĂ©s, creusĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### tisser -- **Racine** : `"tiss"` -- **Couvre** : tisse, tisses, tissent, tissons, tissez, tissais, tissait, tissions, tissiez, tissaient, tisserai, tisseras, tissera, tisserons, tisserez, tisseront, tissant, tissĂ©, tissĂ©e, tissĂ©s, tissĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### forger -- **Racine** : `"forg"` -- **Couvre** : forge, forges, forgent, forgeons, forgez, forgeais, forgeait, forgions, forgiez, forgeaient, forgerai, forgeras, forgera, forgerons, forgerez, forgeront, forgeant, forgĂ©, forgĂ©e, forgĂ©s, forgĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## Verbes de combat et dĂ©fense - -### dĂ©fendre -- **Racine** : `"dĂ©fen"` -- **Couvre** : dĂ©fends, dĂ©fend, dĂ©fendons, dĂ©fendez, dĂ©fendais, dĂ©fendait, dĂ©fendions, dĂ©fendiez, dĂ©fendaient, dĂ©fendrai, dĂ©fendras, dĂ©fendra, dĂ©fendrons, dĂ©fendrez, dĂ©fendront, dĂ©fendant -- **Exceptions** : "dĂ©fendent" (prĂ©sent 3e pl.), "dĂ©fendu" (participe passĂ©) -- **Note** : Verbe en -endre, racine "dĂ©fen" stable - -### surveiller -- **Racine** : `"surveill"` -- **Couvre** : surveille, surveilles, surveillent, surveillons, surveillez, surveillais, surveillait, surveillions, surveilliez, surveillaient, surveillerai, surveilleras, surveillera, surveillerons, surveillerez, surveilleront, surveillant, surveillĂ©, surveillĂ©e, surveillĂ©s, surveillĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### attaquer -- **Racine** : `"attaqu"` -- **Couvre** : attaque, attaques, attaquent, attaquons, attaquez, attaquais, attaquait, attaquions, attaquiez, attaquaient, attaquerai, attaqueras, attaquera, attaquerons, attaquerez, attaqueront, attaquant, attaquĂ©, attaquĂ©e, attaquĂ©s, attaquĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### capturer -- **Racine** : `"captur"` -- **Couvre** : capture, captures, capturent, capturons, capturez, capturais, capturait, capturions, capturiez, capturaient, capturerai, captureras, capturera, capturerons, capturerez, captureront, capturant, capturĂ©, capturĂ©e, capturĂ©s, capturĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### vaincre -- **Racine** : `"vainc"` -- **Couvre** : vaincs, vainc, vainquons, vainquez, vainquais, vainquait, vainquions, vainquiez, vainquaient, vaincrai, vaincras, vaincra, vaincrons, vaincrez, vaincront, vainquant -- **Exceptions** : "vainquent" (prĂ©sent 3e pl.), "vaincu" (participe passĂ©) -- **Note** : Verbe en -incre, racine "vainc" stable avec variante "vainqu" au pluriel - ---- - -## Verbes de commerce et Ă©change - -### troquer -- **Racine** : `"troqu"` -- **Couvre** : troque, troques, troquent, troquons, troquez, troquais, troquait, troquions, troquiez, troquaient, troquerai, troqueras, troquera, troquerons, troquerez, troqueront, troquant, troquĂ©, troquĂ©e, troquĂ©s, troquĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### entreposer -- **Racine** : `"entrepos"` -- **Couvre** : entrepose, entreposes, entreposent, entreposons, entreposez, entreposais, entreposait, entreposions, entreposiez, entreposaient, entreposerai, entreposeras, entreposera, entreposerons, entreposerez, entreposeront, entreposant, entreposĂ©, entreposĂ©e, entreposĂ©s, entreposĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## Verbes de justice et vĂ©ritĂ© - -### arbitrer -- **Racine** : `"arbitr"` -- **Couvre** : arbitre, arbitres, arbitrent, arbitrons, arbitrez, arbitrais, arbitrait, arbitrions, arbitriez, arbitraient, arbitrerai, arbitreras, arbitrera, arbitrerons, arbitrerez, arbitreront, arbitrant, arbitrĂ©, arbitrĂ©e, arbitrĂ©s, arbitrĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## Verbes de subsistance - -### pĂȘcher -- **Racine** : `"pĂȘch"` -- **Couvre** : pĂȘche, pĂȘches, pĂȘchent, pĂȘchons, pĂȘchez, pĂȘchais, pĂȘchait, pĂȘchions, pĂȘchiez, pĂȘchaient, pĂȘcherai, pĂȘcheras, pĂȘchera, pĂȘcherons, pĂȘcherez, pĂȘcheront, pĂȘchant, pĂȘchĂ©, pĂȘchĂ©e, pĂȘchĂ©s, pĂȘchĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### manger -- **Racine** : `"mang"` -- **Couvre** : mange, manges, mangent, mangeons, mangez, mangeais, mangeait, mangions, mangiez, mangeaient, mangerai, mangeras, mangera, mangerons, mangerez, mangeront, mangeant, mangĂ©, mangĂ©e, mangĂ©s, mangĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - -### dĂ©vorer -- **Racine** : `"dĂ©vor"` -- **Couvre** : dĂ©vore, dĂ©vores, dĂ©vorent, dĂ©vorons, dĂ©vorez, dĂ©vorais, dĂ©vorait, dĂ©vorions, dĂ©voriez, dĂ©voraient, dĂ©vorerai, dĂ©voreras, dĂ©vorera, dĂ©vorerons, dĂ©vorerez, dĂ©voreront, dĂ©vorant, dĂ©vorĂ©, dĂ©vorĂ©e, dĂ©vorĂ©s, dĂ©vorĂ©es -- **Exceptions** : aucune (verbe parfaitement rĂ©gulier) - ---- - -## RĂ©sumĂ© statistique - -**Total de verbes traitĂ©s** : 43 verbes (+ leurs synonymes listĂ©s) - -### Distribution des longueurs de racines - -| Longueur | Nombre | Exemples | -|----------|--------|----------| -| 2 lettres | 2 | `di` (dire), `voi` (voir) | -| 3 lettres | 10 | `crĂ©` (crĂ©er), `pri` (prier), `gard` (garder), `port` (porter), `mang` (manger), `pein` (peindre), `tiss` (tisser), `forg` (forger), `grav` (graver), `pĂȘch` (pĂȘcher) | -| 4 lettres | 17 | `donn` (donner), `pren` (prendre), `chass` (chasser), `parl` (parler), `bĂ©ni` (bĂ©nir), `tiss` (tisser), `creus` (creuser), `vainc` (vaincre), `dĂ©fen` (dĂ©fendre), `attaqu` (attaquer), `troqu` (troquer), `captur` (capturer), `arbitr` (arbitrer), `dĂ©vor` (dĂ©vorer), `Ă©tudi` (Ă©tudier), `meur` (mourir) | -| 5 lettres | 9 | `observ` (observer), `regard` (regarder), `Ă©cout` (Ă©couter), `enseign` (enseigner), `explor` (explorer), `protĂšg` (protĂ©ger), `traqu` (traquer), `invoqu` (invoquer), `sculpt` (sculpter) | -| 6 lettres | 3 | `assembl` (assembler), `communi` (communier), `surveill` (surveiller) | -| 7+ lettres | 5 | `construi` (construire), `transmet` (transmettre), `mĂ©moris` (mĂ©moriser), `dĂ©couvr` (dĂ©couvrir), `interprĂšt` (interprĂ©ter), `transport` (transporter), `entrepos` (entreposer) | -| NULL (irrĂ©guliers) | 1 | `aller` (trop irrĂ©gulier) | - -### Verbes parfaitement rĂ©guliers (34/43) - -Les verbes suivants ont une racine qui couvre 100% des formes sans exception : -- donner, observer, regarder, Ă©couter, parler, crĂ©er, assembler, enseigner, mĂ©moriser, Ă©tudier, explorer, garder, porter, transporter, chasser, traquer, mĂ©diter, prier, invoquer, communier, graver, sculpter, creuser, tisser, forger, surveiller, attaquer, capturer, troquer, entreposer, arbitrer, pĂȘcher, manger, dĂ©vorer - -### Verbes irrĂ©guliers avec exceptions notables (9/43) - -- **voir** : trĂšs irrĂ©gulier (voi/voy/verr/v-) -- **aller** : totalement irrĂ©gulier (null recommandĂ©) -- **faire** : 3 radicaux (fai/f/fer) -- **dire** : exception "dites" -- **savoir** : 4 radicaux (sav/sach/saur/su) -- **prendre** : exceptions "prennent", "pris" -- **mourir** : 3 radicaux (meur/mour/mort) -- **peindre** : pein/peign -- **vaincre** : vainc/vainqu - ---- - -## Notes d'implĂ©mentation - -1. **Pour les verbes rĂ©guliers** : La racine couvre toutes les formes, pas besoin de synonymes_fr supplĂ©mentaires -2. **Pour les verbes irrĂ©guliers** : Ajouter dans synonymes_fr les formes qui ne suivent pas la racine principale -3. **Cas spĂ©cial "aller"** : Recommandation de stocker toutes les conjugaisons courantes dans synonymes_fr -4. **Variations orthographiques** : Les verbes avec Ăš/Ă© (protĂ©ger, interprĂ©ter) gardent la racine avec Ăš majoritaire - ---- - -*Document gĂ©nĂ©rĂ© pour le projet Confluent - civjdr* -*DerniĂšre mise Ă  jour : 2025-11-28* diff --git a/docs/TRAVAIL_RACINES_FRANCAISES.md b/docs/TRAVAIL_RACINES_FRANCAISES.md deleted file mode 100644 index df11168..0000000 --- a/docs/TRAVAIL_RACINES_FRANCAISES.md +++ /dev/null @@ -1,475 +0,0 @@ -# Travail : SystĂšme de Racines Françaises - -## Objectif - -AmĂ©liorer le matching des mots français conjuguĂ©s/accordĂ©s en utilisant un systĂšme de **racines françaises** au lieu de se fier uniquement Ă  la lemmatisation automatique. - -## ProblĂšme actuel - -- "manger" trouve "mukis" ✅ -- "mangĂ©" ne trouve RIEN ❌ -- "vu" ne trouve pas "voir" ❌ -- "pris" ne trouve pas "prendre" ❌ - -Le lemmatizer actuel est trop basique et rate beaucoup de formes conjuguĂ©es. - -## Solution : SystĂšme hybride avec racines manuelles - -### 1. DĂ©claration manuelle des racines françaises dans le lexique - -**Principe** : Ajouter un champ `racine_fr` dans chaque entrĂ©e du lexique avec le **dĂ©nominateur commun le plus long** qui couvre toutes les conjugaisons/formes du mot. - -**IMPORTANT** : Ce n'est PAS une extraction automatique des 4 premiĂšres lettres. C'est un **travail manuel intelligent** pour dĂ©terminer la meilleure racine pour chaque mot. - -**Exemples** : -- "manger" → `racine_fr: "mang"` (4 lettres) → couvre mangĂ©, mange, mangeait, mangerons... -- "donner" → `racine_fr: "donn"` (4 lettres) → couvre donnĂ©, donne, donnait, donnerons... -- "comparer" → `racine_fr: "compar"` (6 lettres) → couvre comparĂ©, compare, comparaison... -- "comprendre" → `racine_fr: "compr"` (5 lettres) → couvre compris, comprend, comprenait... - -**Structure dans le lexique** : -```json -"manger": { - "racine_fr": "mang", - "traductions": [...], - "synonymes_fr": ["mange", "mangĂ©", "mangeait"] -} - -"comparer": { - "racine_fr": "compar", - "traductions": [...], - "synonymes_fr": ["comparĂ©", "compare", "comparaison"] -} - -"comprendre": { - "racine_fr": "compr", - "traductions": [...], - "synonymes_fr": ["compris", "comprend", "comprenait"] -} -``` - -**Comportement du matching** : - -Quand l'utilisateur tape "comparĂ©" : -1. Le systĂšme cherche les entrĂ©es dont `racine_fr` matche le dĂ©but de "comparĂ©" -2. Il trouve `"compar"` → match "comparer" ✅ -3. Il ne trouve PAS `"compr"` (trop court) → ne propose pas "comprendre" ✅ - -Quand l'utilisateur tape "comprend" : -1. Le systĂšme trouve : - - `"compr"` (5 lettres) → match "comprendre" ✅ - - `"comp"` pourrait aussi matcher si on avait un mot avec cette racine -2. En cas de **multiples matches**, le systĂšme retourne **TOUS les candidats** au LLM -3. Le **LLM choisit** selon le contexte de la phrase - -**Avantages** : -- ContrĂŽle total sur la longueur de chaque racine (4, 5, 6 lettres selon le besoin) -- GĂšre les ambiguĂŻtĂ©s en laissant le LLM arbitrer -- Plus prĂ©cis qu'une extraction automatique aveugle - -### 2. Formes irrĂ©guliĂšres dans `synonymes_fr` - -**Principe** : Ajouter toutes les formes conjuguĂ©es dans le champ `synonymes_fr` du lexique - -**Exemples de cas nĂ©cessitant `synonymes_fr`** : - -#### Formes trop diffĂ©rentes de la racine -- **"voir"** → `racine_fr: "voi"` couvre "voit", "voyait", "voyons" - - MAIS "vu", "vus", "vue", "vues" sont trop diffĂ©rents → Ă  mettre dans `synonymes_fr` - -- **"ĂȘtre"** → formes trop diffĂ©rentes (est, suis, sont, Ă©tĂ©, Ă©tait, sera, fut...) - - Impossible d'avoir une racine unique → tout dans `synonymes_fr` - -- **"avoir"** → formes trop diffĂ©rentes (a, ai, ont, eu, avait, aura...) - - Impossible d'avoir une racine unique → tout dans `synonymes_fr` - -#### Verbes irrĂ©guliers avec changement de radical -- **"prendre"** → `racine_fr: "pren"` couvre "prend", "prenait", "prendra" - - MAIS "pris", "prit", "prise" ont un radical diffĂ©rent → dans `synonymes_fr` - -- **"faire"** → `racine_fr: "fai"` couvre "fais", "faisait", "faisons" - - MAIS "fait", "faite", "faites" ont un radical diffĂ©rent → dans `synonymes_fr` - -**Combinaison racine + synonymes** : -```json -"voir": { - "racine_fr": "voi", - "synonymes_fr": ["vu", "vus", "vue", "vues", "observer", "regarder"] -} - -"prendre": { - "racine_fr": "pren", - "synonymes_fr": ["pris", "prit", "prise", "prises"] -} -``` - -Le systĂšme essaie d'abord la racine, puis les synonymes. - ---- - -## TRAVAIL 1 : Modification du code (contextAnalyzer.js) - -**Fichier** : `ConfluentTranslator/contextAnalyzer.js` - -### Modifications Ă  faire : - -#### A. Modifier searchWord() pour utiliser le champ `racine_fr` - -**Principe** : Chercher les entrĂ©es dont le champ `racine_fr` est **contenu au dĂ©but** du mot recherchĂ©. - -**Emplacement** : ligne ~124 dans la fonction `searchWord()` - -**Modifier la logique de matching pour ajouter** : -```javascript - // NOUVEAU: Correspondance sur racine française dĂ©clarĂ©e - // Si l'entrĂ©e a un champ racine_fr et que le mot commence par cette racine - else if (entry.racine_fr && word.startsWith(entry.racine_fr.toLowerCase())) { - score = 0.75; - } -``` - -**Insertion dans la cascade de matching** (aprĂšs synonymes lemmatisĂ©s, avant le return) : -```javascript - // Correspondance exacte sur le mot français - if (key === word || entry.mot_francais?.toLowerCase() === word) { - score = 1.0; - } - // Correspondance sur formes lemmatisĂ©es - else if (lemmas.some(lemma => key === lemma || entry.mot_francais?.toLowerCase() === lemma)) { - score = 0.95; - } - // Correspondance sur synonymes - else if (entry.synonymes_fr?.some(syn => syn.toLowerCase() === word)) { - score = 0.9; - } - // Correspondance sur synonymes lemmatisĂ©s - else if (entry.synonymes_fr?.some(syn => lemmas.includes(syn.toLowerCase()))) { - score = 0.85; - } - // NOUVEAU: Correspondance sur racine française dĂ©clarĂ©e - else if (entry.racine_fr && word.startsWith(entry.racine_fr.toLowerCase())) { - score = 0.75; - } -``` - -**Code final de searchWord()** : -```javascript -function searchWord(word, dictionnaire) { - const results = []; - const lemmas = simpleLemmatize(word); - - for (const [key, entry] of Object.entries(dictionnaire)) { - let score = 0; - - // Correspondance exacte sur le mot français - if (key === word || entry.mot_francais?.toLowerCase() === word) { - score = 1.0; - } - // Correspondance sur formes lemmatisĂ©es - else if (lemmas.some(lemma => key === lemma || entry.mot_francais?.toLowerCase() === lemma)) { - score = 0.95; - } - // Correspondance sur synonymes - else if (entry.synonymes_fr?.some(syn => syn.toLowerCase() === word)) { - score = 0.9; - } - // Correspondance sur synonymes lemmatisĂ©s - else if (entry.synonymes_fr?.some(syn => lemmas.includes(syn.toLowerCase()))) { - score = 0.85; - } - // NOUVEAU: Correspondance sur racine française dĂ©clarĂ©e dans le lexique - else if (entry.racine_fr && word.startsWith(entry.racine_fr.toLowerCase())) { - score = 0.75; - } - - if (score > 0) { - results.push({ - mot_francais: entry.mot_francais || key, - traductions: entry.traductions || [], - score, - source: entry.source_files || [] - }); - } - } - - return results; -} -``` - -**Note** : Pas besoin d'exporter de nouvelle fonction, on utilise simplement le champ `racine_fr` du lexique. - ---- - -## TRAVAIL 2 : ComplĂ©ter le lexique avec racines et synonymes - -**Objectif** : Pour chaque verbe du lexique, ajouter : -1. Le champ `racine_fr` avec le dĂ©nominateur commun optimal -2. Les formes conjuguĂ©es irrĂ©guliĂšres dans `synonymes_fr` - -### Fichiers Ă  modifier : - -`ancien-confluent/lexique/06-actions.json` - -### Structure Ă  suivre pour chaque verbe - -```json -"[verbe_infinitif]": { - "racine_fr": "[racine_optimale]", - "traductions": [...], - "synonymes_fr": ["[formes_irrĂ©guliĂšres]", "[autres_synonymes]"] -} -``` - -### Verbes Ă  complĂ©ter (par prioritĂ©) - -#### PrioritĂ© 1 : Verbes trĂšs courants - -**1. voir** -```json -"voir": { - "racine_fr": "voi", - "traductions": [...], - "synonymes_fr": ["observer", "regarder", "vu", "vus", "vue", "vues"] -} -``` -*Note : "voit", "voyait", "voyons", "verra" sont couverts par la racine "voi". Seules les formes avec radical diffĂ©rent (vu/vue) vont dans synonymes_fr.* - -**2. prendre** -```json -"prendre": { - "racine_fr": "pren", - "traductions": [...], - "synonymes_fr": ["pris", "prit", "prise", "prises"] -} -``` -*Note : "prend", "prenait", "prendra" sont couverts par la racine "pren".* - -**3. faire** -```json -"faire": { - "racine_fr": "fai", - "traductions": [...], - "synonymes_fr": ["crĂ©er", "fait", "faits", "faite", "faites"] -} -``` -*Note : "fais", "faisait", "faisons" sont couverts par la racine "fai".* - -**4. manger** (nouveau verbe si pas dĂ©jĂ  prĂ©sent) -```json -"manger": { - "racine_fr": "mang", - "traductions": [...], - "synonymes_fr": [] -} -``` -*Note : Toutes les formes (mange, mangĂ©, mangeait, mangera) sont couvertes par la racine "mang". Pas besoin de synonymes.* - -**5. aller** -```json -"aller": { - "racine_fr": "all", - "traductions": [...], - "synonymes_fr": ["va", "vas", "vais", "ira", "iras", "iront"] -} -``` -*Note : "allĂ©", "allait" sont couverts par "all". Les formes irrĂ©guliĂšres (va/vais, ira) vont dans synonymes_fr.* - -**6. donner** -```json -"donner": { - "racine_fr": "donn", - "traductions": [...], - "synonymes_fr": [] -} -``` -*Note : Toutes les formes sont couvertes par "donn".* - -**7. dire** -```json -"dire": { - "racine_fr": "di", - "traductions": [...], - "synonymes_fr": ["parler", "dit", "dits", "dite", "dites"] -} -``` -*Note : "dis", "disait", "dira" sont couverts par "di". "dit/dite" ont un radical diffĂ©rent donc dans synonymes_fr.* - -#### PrioritĂ© 2 : Verbes auxiliaires (trĂšs irrĂ©guliers) - -**8. ĂȘtre** -```json -"ĂȘtre": { - "racine_fr": null, - "traductions": [...], - "synonymes_fr": ["est", "es", "suis", "sont", "sommes", "ĂȘtes", "Ă©tĂ©", "Ă©tait", "Ă©tais", "Ă©tant", "sera", "seras", "seront", "fut", "fus"] -} -``` -*Note : Aucune racine commune possible. Toutes les formes dans synonymes_fr.* - -**9. avoir** -```json -"avoir": { - "racine_fr": "av", - "traductions": [...], - "synonymes_fr": ["a", "as", "ai", "ont", "eu", "eue", "eus", "eues", "aura", "auras", "auront"] -} -``` -*Note : "avait", "avais", "avons", "avez" couverts par "av". Formes irrĂ©guliĂšres (a/ai/ont, eu, aura) dans synonymes_fr.* - -#### PrioritĂ© 3 : Autres verbes courants - -**10. savoir** -```json -"savoir": { - "racine_fr": "sav", - "traductions": [...], - "synonymes_fr": ["connaĂźtre", "sait", "sais", "su", "sue", "sus", "sues", "saura", "sauront"] -} -``` -*Note : "savait", "savons", "sachant" couverts par "sav". Formes irrĂ©guliĂšres (sait/sais, su, saura) dans synonymes_fr.* - -**11. chasser** -```json -"chasser": { - "racine_fr": "chass", - "traductions": [...], - "synonymes_fr": ["traquer"] -} -``` -*Note : Toutes les conjugaisons couvertes par "chass".* - -**12. transmettre** -```json -"transmettre": { - "racine_fr": "transm", - "traductions": [...], - "synonymes_fr": ["enseigner", "transmis", "transmise", "transmises"] -} -``` -*Note : "transmet", "transmettait", "transmettra" couverts par "transm". Participe passĂ© (transmis) dans synonymes_fr.* - -**13. garder** -```json -"garder": { - "racine_fr": "gard", - "traductions": [...], - "synonymes_fr": ["protĂ©ger"] -} -``` -*Note : Toutes les conjugaisons couvertes par "gard".* - -**14. porter** -```json -"porter": { - "racine_fr": "port", - "traductions": [...], - "synonymes_fr": ["transporter"] -} -``` -*Note : Toutes les conjugaisons couvertes par "port".* - -**15. apprendre** -```json -"apprendre": { - "racine_fr": "appren", - "traductions": [...], - "synonymes_fr": ["appris", "apprise", "apprises"] -} -``` -*Note : "apprend", "apprenait", "apprendra" couverts par "appren". Participe passĂ© (appris) dans synonymes_fr.* - ---- - -## Tests Ă  faire aprĂšs modifications - -### Test 1 : VĂ©rifier les racines automatiques - -```bash -curl -X POST http://localhost:3000/api/debug/prompt \ - -H "Content-Type: application/json" \ - -d '{"text": "Il mangeait le pain", "target": "ancien"}' | grep -A 5 "wordsFound" -``` - -**RĂ©sultat attendu** : "mangeait" → trouve "mukis" via racine "mang" - -### Test 2 : VĂ©rifier les exceptions manuelles - -```bash -curl -X POST http://localhost:3000/api/debug/prompt \ - -H "Content-Type: application/json" \ - -d '{"text": "Il a vu et pris", "target": "ancien"}' | grep -A 10 "wordsFound" -``` - -**RĂ©sultat attendu** : -- "vu" → trouve "mirak" via synonymes_fr -- "pris" → trouve "pasak" via synonymes_fr - -### Test 3 : Phrase complĂšte - -```bash -# MĂȘme test que le problĂ©matique -curl -X POST http://localhost:3000/api/debug/prompt \ - -H "Content-Type: application/json" \ - -d '{"text": "C est le collier du loup qui a mange mon frere", "target": "ancien"}' | python -c "import sys, json; data=json.load(sys.stdin); print('Found:', [w['input'] for w in data['metadata']['wordsFound']])" -``` - -**RĂ©sultat attendu** : ["collier", "loup", "mange", "frere"] tous trouvĂ©s - ---- - -## Estimation de travail - -- **Code (contextAnalyzer.js)** : ~5 lignes Ă  ajouter (une seule condition else if), 5 minutes -- **Lexique (06-actions.json)** : - - Ajouter champ `racine_fr` pour 15 verbes : ~15 minutes - - Ajouter formes irrĂ©guliĂšres dans `synonymes_fr` : ~30 formes uniques, ~20 minutes - -**Total** : ~40 minutes de travail - -**RĂ©vision par rapport Ă  l'estimation initiale** : Beaucoup plus simple car on ne fait pas d'extraction automatique, juste du matching sur un champ dĂ©clarĂ©. - ---- - -## Notes importantes - -1. **Lowercase** : Tout est dĂ©jĂ  en lowercase dans tokenizeFrench(), pas besoin de le refaire dans le matching -2. **Normalisation des accents** : DĂ©jĂ  fait en amont (mangĂ© → mange dans la tokenization) -3. **Ordre de prioritĂ© matching** : - - 1.0 = Exacte - - 0.95 = Lemma - - 0.9 = Synonyme exact - - 0.85 = Synonyme lemmatisĂ© - - **0.75 = Racine française dĂ©clarĂ©e** (NOUVEAU) -4. **Choix de la racine** : - - Doit ĂȘtre le **dĂ©nominateur commun le plus long** qui couvre la majoritĂ© des conjugaisons - - Exemples : "mang" (4 lettres), "compar" (6 lettres), "transm" (6 lettres) - - Pas de rĂšgle fixe sur la longueur : dĂ©cision au cas par cas -5. **Multiples matches** : - - Si plusieurs entrĂ©es matchent (ex: "comp" et "compr"), TOUTES sont retournĂ©es au LLM - - Le LLM choisit selon le contexte de la phrase - - Pas de filtrage automatique - ---- - -## RĂ©sumĂ© du systĂšme final - -### Workflow de matching pour un mot tapĂ© par l'utilisateur - -1. L'utilisateur tape "comparĂ©" -2. Le systĂšme tokenize et met en lowercase → "compare" (accent normalisĂ©) -3. Le systĂšme cherche dans le lexique avec cette cascade : - - **Score 1.0** : Match exact sur clĂ© ou `mot_francais` → ❌ - - **Score 0.95** : Match sur lemme → ❌ - - **Score 0.9** : Match exact dans `synonymes_fr` → ❌ - - **Score 0.85** : Match lemme dans `synonymes_fr` → ❌ - - **Score 0.75** : `"compare".startsWith(entry.racine_fr)` → ✅ trouve "compar" dans l'entrĂ©e "comparer" -4. Le systĂšme retourne l'entrĂ©e "comparer" avec score 0.75 -5. Le LLM utilise la traduction confluente - -### Avantages de cette approche - -- ✅ **ContrĂŽle total** : chaque racine est choisie manuellement pour ĂȘtre optimale -- ✅ **AmbiguĂŻtĂ© gĂ©rĂ©e** : multiples matches possibles, le LLM arbitre -- ✅ **Performance** : pas de calcul complexe, juste du `startsWith()` -- ✅ **Maintenance** : facile d'ajuster une racine si elle ne convient pas -- ✅ **Hybride intelligent** : racines pour les formes rĂ©guliĂšres, synonymes pour les irrĂ©guliĂšres diff --git a/docs/langue/01-PHONOLOGIE.md b/docs/langue/01-PHONOLOGIE.md new file mode 100644 index 0000000..14e9eb5 --- /dev/null +++ b/docs/langue/01-PHONOLOGIE.md @@ -0,0 +1,291 @@ +# 01 - PHONOLOGIE DU CONFLUENT + +La phonologie du Confluent reflĂšte la philosophie de la Civilisation de la Confluence : clartĂ© de l'observation, fluiditĂ© de l'eau, et rĂ©sonance des Ă©chos dans les grottes sacrĂ©es. + +--- + +## Philosophie sonore + +Le Confluent est une langue conçue pour **rĂ©sonner** dans les Antres des Échos et **porter** sur les vents de montagne. Chaque son a Ă©tĂ© choisi pour sa capacitĂ© Ă  : + +1. **RĂ©sonner** dans les espaces souterrains sans confusion +2. **Porter** sur de longues distances en montagne +3. **S'harmoniser** avec les sons naturels (eau, vent, oiseaux) +4. **Se distinguer** clairement Ă  l'oral comme Ă  l'Ă©crit + +--- + +## Inventaire phonĂ©tique + +### Consonnes (10) + +Le Confluent utilise 10 consonnes, choisies pour leur clartĂ© acoustique : + +| Consonne | Type | Description | Exemples | +|----------|------|-------------|----------| +| **b** | Occlusive bilabiale sonore | Comme "bateau" | **b**esi (bĂȘte), **b**uki (bois) | +| **k** | Occlusive vĂ©laire sourde | Comme "kayak" | **k**ota (union), **k**ori (cƓur) | +| **l** | LatĂ©rale alvĂ©olaire | Comme "lumiĂšre" | **l**una (lune), a**l**u (grue) | +| **m** | Nasale bilabiale | Comme "montagne" | **m**ira (voir), u**m**i (esprit) | +| **n** | Nasale alvĂ©olaire | Comme "nuit" | **n**aki (enfant), e**n**a (origine) | +| **p** | Occlusive bilabiale sourde | Comme "pierre" | **p**asa (prendre), a**p**o (oiseau) | +| **s** | Fricative alvĂ©olaire sourde | Comme "silence" | **s**ili (regard), a**s**ka (libre) | +| **t** | Occlusive alvĂ©olaire sourde | Comme "terre" | **t**oka (terre), i**t**a (ĂȘtre) | +| **v** | Fricative labiodentale sonore | Comme "vent" | **v**ela (vigile), **v**oki (voix) | +| **z** | Fricative alvĂ©olaire sonore | Comme "zĂ©ro" | **z**ana (chasser), **z**ero (ciel) | + +#### Choix phonĂ©tiques volontaires + +**ÉvitĂ©s** : +- Sons elfiques (th, ch, j) +- Sons gutturaux (r roulĂ©, h aspirĂ©) +- Sons trop latins (ph, gh) + +**Ratio inspirationnel** : +- 70% crĂ©ations originales +- 20% inspiration finno-ougrienne (harmonie vocalique) +- 10% inspiration basque (structure CV) + +### Voyelles actives (5) + +Le Confluent possĂšde 5 voyelles principales, claires et distinctes : + +| Voyelle | Type | Prononciation | Exemples | +|---------|------|---------------|----------| +| **a** | Ouverte centrale | Comme "patte" | **a**ska (libre), ur**a** (eau) | +| **e** | Mi-fermĂ©e antĂ©rieure | Comme "Ă©tĂ©" | **e**ka (tout), k**e**ko (Ă©cho) | +| **i** | FermĂ©e antĂ©rieure | Comme "Ăźle" | s**i**li (regard), um**i** (esprit) | +| **o** | Mi-fermĂ©e postĂ©rieure | Comme "eau" | t**o**ka (terre), ik**o** (un) | +| **u** | FermĂ©e postĂ©rieure | Comme "loup" | **u**ra (eau), val**u** (valeur) | + +### Voyelles rĂ©servĂ©es (3) + +RĂ©servĂ©es pour expansion linguistique future : + +| Voyelle | Statut | Usage futur possible | +|---------|--------|---------------------| +| **y** | RĂ©servĂ©e | Diphtongues complexes, registre poĂ©tique | +| **Ă©** | RĂ©servĂ©e | Distinctions tonales, emphase | +| **Ăš** | RĂ©servĂ©e | Registre archaĂŻque, formules rituelles | + +--- + +## Orthographe et conventions + +### Principe fondamental : tout en minuscules + +**⚠ RÈGLE ABSOLUE** : Le Confluent n'a **aucune distinction majuscule/minuscule**. + +``` +❌ INCORRECT +Siliaska, Uraakota, Aliaska + +✅ CORRECT +siliaska, uraakota, aliaska +``` + +**Justification culturelle** : +Dans la philosophie de la Confluence, tous les ĂȘtres sont Ă©gaux devant l'eau qui coule. Les castes, les lieux, les personnes sont tous Ă©crits en minuscules pour reflĂ©ter cette Ă©galitĂ© spirituelle fondamentale. + +**Exception pratique** : En dĂ©but de phrase, une majuscule peut ĂȘtre utilisĂ©e pour la lisibilitĂ© en français, mais ce n'est pas une rĂšgle du Confluent lui-mĂȘme. + +### Transparence phonĂ©tique + +**Une lettre = un son, un son = une lettre** + +Le Confluent suit un principe de transparence orthographique absolue : +- Pas de lettres muettes +- Pas de digraphes (ch, th, ph) +- Pas de sons complexes + +``` +Écrit : s-i-l-i-a-s-k-a +PrononcĂ© : si-li-as-ka +``` + +--- + +## RĂšgles phonotactiques + +### Structure syllabique + +Le Confluent privilĂ©gie la structure **CV** (Consonne + Voyelle) : + +| Type | Structure | Exemples | FrĂ©quence | +|------|-----------|----------|-----------| +| **CV** | Consonne + Voyelle | si-li, u-ra, to-ka | 90% | +| **V** | Voyelle seule | a-ska, u-mi, i-ko | 10% (racines sacrĂ©es) | + +**❌ Structures interdites** : +- CVC en milieu de mot (sauf fin de verbe) +- Groupes consonantiques (tr, pl, kr) +- Voyelles consĂ©cutives (sauf liaisons sacrĂ©es) + +### Finales de mots + +**RĂšgle fondamentale** : Les racines finissent **toujours par une voyelle**. + +``` +✅ Racines (CV finale) +sili, aska, kota, ura + +✅ Verbes (C finale) +mirak, nekan, vosak, kisun + +❌ Impossible +sil, ask, kot (pas de consonnes finales pour les racines) +``` + +--- + +## Euphonie et harmonie sonore + +### Principe de fluiditĂ© + +Le Confluent Ă©vite les combinaisons difficiles Ă  prononcer : + +**Éviter** : +- 3 consonnes consĂ©cutives : *silktosa ❌ → sil-i-tosa ✅ +- Voyelles identiques : *uraa ❌ → ura-a (sĂ©paration) ✅ +- Sons gutturaux successifs : *kgb* (impossible) + +### Harmonie vocalique (tendance) + +Bien que non obligatoire, il existe une **tendance** Ă  l'harmonie vocalique dans les compositions, inspirĂ©e du finnois : + +**Voyelles antĂ©rieures** (e, i) tendent Ă  s'associer : +- sil-**i**-ask**a** (regard-libre) +- k**e**k-**u**-tok**a** (Ă©cho-terre) + +**Voyelles postĂ©rieures** (o, u) tendent Ă  s'associer : +- ur-**aa**-k**o**t**a** (eau-union) +- v**u**k-**u**-**u**r**a** (gouffre-eau) + +Cette harmonie n'est **pas obligatoire**, mais elle est valorisĂ©e pour son esthĂ©tique sonore. + +### RĂ©sonance dans les Antres + +Les Enfants des Échos (Nakukeko) ont dĂ©veloppĂ© une sensibilitĂ© particuliĂšre aux propriĂ©tĂ©s acoustiques du Confluent : + +**Sons qui rĂ©sonnent bien** : +- Nasales (m, n) : portent loin dans les grottes +- Sifflantes (s, z) : Ă©cho distinctif +- Voyelles ouvertes (a, o) : amplification naturelle + +**Exemple** : Le nom "**nakukeko**" (Enfants des Échos) utilise : +- 3 occlusives (k) pour l'Ă©cho percussif +- Voyelles alternĂ©es (a-u-e-o) pour la variĂ©tĂ© sonore +- Structure rĂ©pĂ©titive (na-ku-ke-ko) mimant l'Ă©cho lui-mĂȘme + +--- + +## PhonĂ©tique sacrĂ©e vs standard + +### Distinction initiale + +| Type | DĂ©but | SonoritĂ© | Statut | Exemples | +|------|-------|----------|--------|----------| +| **SacrĂ©e** | Voyelle (V-) | Ouverte, rĂ©sonnante | Ancienne, fondamentale | **a**ska, **u**ra, **i**ta | +| **Standard** | Consonne (C-) | ArticulĂ©e, prĂ©cise | RĂ©cente, quotidienne | **s**ili, **k**ota, **t**oka | + +**Ratio** : ~20% sacrĂ©es, ~80% standards + +**Justification** : Les racines sacrĂ©es commencent par une voyelle car elles reprĂ©sentent des concepts **primordiaux**, existant avant toute articulation humaine. Les racines standards commencent par une consonne car elles reprĂ©sentent des **crĂ©ations humaines**, nĂ©cessitant une articulation volontaire. + +### Exemples comparĂ©s + +| SacrĂ© (V-) | Standard (C-) | DiffĂ©rence | +|------------|---------------|------------| +| **aska** (libre) | **sili** (regard) | Concept abstrait vs observation concrĂšte | +| **ura** (eau) | **nura** (riviĂšre) | ÉlĂ©ment primordial vs manifestation locale | +| **umi** (esprit) | **kori** (cƓur) | Essence spirituelle vs organe physique | + +--- + +## Évolution phonĂ©tique + +### Du Proto-Confluent Ă  l'Ancien Confluent + +Le Confluent a Ă©voluĂ© depuis une forme proto-linguistique plus simple : + +| Évolution | Proto-Confluent | Ancien Confluent | Changement | +|-----------|-----------------|------------------|------------| +| **Voyelles** | 4 (a, e, i, o) | 5 (a, e, i, o, u) | Ajout du /u/ | +| **Consonnes** | 8 (b, k, l, m, n, p, s, t) | 10 (+v, z) | Ajout fricatives | +| **Structure** | CV strict | CV + verbes CVC | Complexification | + +**Tendance historique** : +- **Simplification** des groupes consonantiques +- **Stabilisation** des finales en voyelle +- **DiffĂ©renciation** verbes (C finale) vs racines (V finale) + +### Changements Ă  venir (Confluent Classique) + +Le systĂšme phonĂ©tique actuel (Ancien Confluent) est **stable et validĂ©**. Évolutions futures possibles : + +1. **Activation des voyelles rĂ©servĂ©es** (y, Ă©, Ăš) +2. **Diphtongues formelles** (ai, au, ei) +3. **Tons ou accents** pour nuances sĂ©mantiques +4. **Registres prosodiques** (rituel vs quotidien) + +--- + +## Exemples phonĂ©tiques annotĂ©s + +### Analyse phonĂ©tique de "Siliaska" + +``` +Siliaska [si-li-as-ka] +│││││││ +│││││└─ ka : CV (occlusive + ouverte) +││││└── as : VC (ouverte + fricative) +│││└─── li : CV (latĂ©rale + fermĂ©e) +││└──── i : liaison sacrĂ©e (agent actif) +│└───── sil: forme liĂ©e de "sili" (regard) +└────── Composition : sil-i-aska + +SonoritĂ© : Liquide (l) + Fricative (s) + VĂ©laire (k) +Harmonie : Voyelles mixtes (i-i-a-a) +RĂ©sonance : Excellente (4 syllabes CV Ă©quilibrĂ©es) +``` + +### Analyse phonĂ©tique de "Uraakota" + +``` +Uraakota [u-ra-a-ko-ta] +│││││││││ +││││││└─ ta : CV (occlusive + ouverte) +│││││└── ko : CV (vĂ©laire + postĂ©rieure) +││││└─── aa : liaison sacrĂ©e (fusion) +│││└──── ur : forme liĂ©e de "ura" (eau) +││└───── kota : racine standard (union) +│└────── Composition : ur-aa-kota + +SonoritĂ© : Fricative (r→liquide) + VĂ©laires (k) + Occlusive (t) +Harmonie : PostĂ©rieures dominantes (u-a-a-o-a) +RĂ©sonance : Puissante (voyelles ouvertes, 5 syllabes) +Symbolisme : Le son mime le flux confluent des eaux +``` + +--- + +## Annexe : Comparaison typologique + +### Inspirations linguistiques + +| Langue | CaractĂ©ristique empruntĂ©e | Application au Confluent | +|--------|---------------------------|--------------------------| +| **Finnois** | Harmonie vocalique | Tendance antĂ©rieur/postĂ©rieur | +| **Basque** | Structure CV stricte | Racines en ...CV | +| **Japonais** | Syllabaire simple | Transparence phonĂ©tique | +| **Quechua** | Suffixes agglutinants | Particules et conjugateurs | +| **Esperanto** | RĂ©gularitĂ© absolue | RĂšgles sans exception | + +### OriginalitĂ© du systĂšme + +Le Confluent n'est **pas** une relexification d'une langue naturelle. C'est une crĂ©ation originale qui emprunte des **principes** Ă  diverses langues tout en maintenant sa propre logique interne, guidĂ©e par la culture de la Civilisation de la Confluence. + +--- + +*Document linguistique - Civilisation de la Confluence* +*Voir aussi : 02-MORPHOLOGIE.md pour la structure des mots* diff --git a/docs/langue/02-MORPHOLOGIE.md b/docs/langue/02-MORPHOLOGIE.md new file mode 100644 index 0000000..3492665 --- /dev/null +++ b/docs/langue/02-MORPHOLOGIE.md @@ -0,0 +1,614 @@ +# 02 - MORPHOLOGIE DU CONFLUENT + +La morphologie du Confluent incarne le principe central de la civilisation : **la confluence**. Les mots se rejoignent et se mĂȘlent comme les eaux de deux riviĂšres, crĂ©ant quelque chose de plus riche que leurs sources sĂ©parĂ©es. + +--- + +## Philosophie morphologique + +Le Confluent est une langue **agglutinante** oĂč les mots complexes se construisent par **composition de racines** liĂ©es par des **liaisons sacrĂ©es**. Cette structure reflĂšte trois valeurs fondamentales : + +1. **Transparence** : L'Ă©tymologie reste visible dans chaque mot composĂ© +2. **Accumulation** : Les mots portent l'histoire de leurs composants +3. **Confluence** : La rencontre de deux concepts crĂ©e un sens nouveau + +--- + +## Structure des racines + +### RĂšgle fondamentale : finale en CV + +**Toute racine se termine par CV** (Consonne + Voyelle) + +``` +✅ RACINES VALIDES +sili (si-li) : regard +toka (to-ka) : terre +vena (ve-na) : air +keko (ke-ko) : Ă©cho + +❌ RACINES INVALIDES +sil (finale C) +tok (finale C) +ven (finale C) +``` + +### Exception : les verbes + +Les verbes sont des racines transformĂ©es qui **finissent par une consonne** (forme CVCVC) : + +``` +RACINE → VERBE +mira → mirak (voir) +neka → nekan (faire) +vosa → vosak (dire) +kisu → kisun (transmettre) +``` + +Cette distinction permet d'identifier immĂ©diatement la classe grammaticale d'un mot : + +| Finale | Classe | Exemples | +|--------|--------|----------| +| **Voyelle** | Nom/Racine | sili, aska, kota | +| **Consonne** | Verbe | mirak, nekan, kisun | + +--- + +## Types de racines + +### Racines sacrĂ©es (~20%) + +Les racines sacrĂ©es commencent par une **voyelle** et reprĂ©sentent des concepts **anciens, fondamentaux et spirituels**. + +**Structure** : V-C-V (Voyelle-Consonne-Voyelle) + +| ID | Forme base | Forme liĂ©e | Sens | Domaine | +|----|------------|------------|------|---------| +| 1 | **aska** | ask- | libre, libertĂ© | Concept fondateur | +| 2 | **aita** | ait- | ancĂȘtre, ancien | LignĂ©e sacrĂ©e | +| 3 | **asa** | as- | sacrĂ©, divin | Spirituel | +| 4 | **apo** | ap- | oiseau, vol | Nature sacrĂ©e | +| 5 | **alu** | al- | grue (Regard-Libre) | Animal sacrĂ© | +| 6 | **aki** | ak- | faucon | Animal sacrĂ© | +| 7 | **ura** | ur- | eau, fluide | ÉlĂ©ment primordial | +| 8 | **umi** | um- | esprit, souffle vital | Spirituel | +| 9 | **iko** | ik- | un, unique, seul | Concept fondateur | +| 10 | **ita** | it- | ĂȘtre, exister | Existence | +| 11 | **ena** | en- | origine, source, naissance | Dimension | +| 12 | **eka** | ek- | tout, entier, totalitĂ© | Dimension | +| 13 | **oki** | ok- | Ă©preuve, dĂ©fi, danger | Conflit sacrĂ© | +| 14 | **ora** | or- | aurore, aube | Moment sacrĂ© | +| 15 | **onu** | on- | son, vibration | Rituel | +| 68 | **anu** | an- | Ăąme, conscience profonde | Spirituel | +| 69 | **eku** | ek- | Ă©toile | CĂ©leste sacrĂ© | +| 70 | **osi** | os- | mort, mourir | Cycle sacrĂ© | +| 71 | **apa** | ap- | aile | Nature sacrĂ©e | + +**CaractĂ©ristiques** : +- DĂ©but vocalique (ouverture, primordialitĂ©) +- Concepts abstraits ou Ă©lĂ©ments primordiaux +- Noyau du vocabulaire rituel et spirituel +- Ratio : 19/176 = ~11% (objectif 20-25%) + +### Racines standards (~80%) + +Les racines standards commencent par une **consonne** et reprĂ©sentent des concepts **quotidiens, techniques et rĂ©cents**. + +**Structure** : C-V-C-V (Consonne-Voyelle-Consonne-Voyelle) + +**Exemples par domaine** : + +#### ÉlĂ©ments naturels +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| zeru | zer- | ciel | +| toka | tok- | terre, sol | +| suki | suk- | feu, flamme | +| vena | ven- | air, vent | +| kari | kar- | pierre, roche | +| nura | nur- | riviĂšre, courant | + +#### Corps et sens +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| sili | sil- | Ɠil, regard, vision | +| kanu | kan- | main | +| voki | vok- | voix, parole | +| tiku | tik- | oreille, Ă©coute | +| kori | kor- | cƓur | + +#### Actions +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| mira | mir- | voir, observer | +| teki | tek- | aller, chemin | +| kita | kit- | donner | +| pasa | pas- | prendre | +| neka | nek- | faire, crĂ©er | + +#### Êtres et relations +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| kota | kot- | union, confluence | +| naki | nak- | enfant, descendant | +| tori | tor- | personne, individu | +| vaku | vak- | ami, alliĂ© | + +**CaractĂ©ristiques** : +- DĂ©but consonantique (articulation, crĂ©ation humaine) +- Concepts concrets ou techniques +- Évolution constante du lexique +- Ratio : 157/176 = ~89% (dans la marge) + +--- + +## Les 16 liaisons sacrĂ©es + +Les liaisons sacrĂ©es sont le **cƓur du systĂšme morphologique** du Confluent. Elles relient deux racines pour crĂ©er un mot composĂ© avec un sens nouveau. + +### Principe de composition + +``` +RACINE₁ (forme liĂ©e) + LIAISON + RACINE₂ → MOT COMPOSÉ + +Exemple : +sili (regard) → sil- +sil- + -i- (agent actif) + aska (libre) +→ siliaska (porteur du regard libre) +``` + +### Algorithme de liaison + +1. **Prendre la racine 1** et retirer sa voyelle finale → **forme liĂ©e** + - sili → sil- + - ura → ur- + - naki → nak- + +2. **Ajouter la liaison sacrĂ©e** appropriĂ©e selon le sens voulu + - sil- + **-i-** (agent) + - ur- + **-aa-** (fusion) + - nak- + **-u-** (appartenance) + +3. **Ajouter la racine 2** intacte + - sil-i-**aska** + - ur-aa-**kota** + - nak-u-**ura** + +4. **RĂ©sultat** : mot composĂ© transparent + - **siliaska** = porteur du regard libre + - **uraakota** = eau confluente, La Confluence + - **nakuura** = enfant de l'eau + +### Tableau complet des liaisons + +#### Domaine I : AgentivitĂ© (celui qui...) + +| Liaison | Concept | Sens | Exemple | +|---------|---------|------|---------| +| **-i-** | actif | celui qui fait, porte, agit | sil-**i**-aska = porteur du regard | +| **-ie-** | rĂ©cepteur | celui qui reçoit, subit | kor-**ie**-vosi = celui qui reçoit la parole | +| **-ii-** | essentiel | celui qui EST (essence) | um-**ii**-tori = personne-esprit (essence) | +| **-iu-** | potentiel | celui qui devient | nak-**iu**-kasi = enfant devenant chef | + +**Usage** : CrĂ©ation d'agents, de rĂŽles, de castes + +#### Domaine U : Appartenance (de, pour) + +| Liaison | Concept | Sens | Exemple | +|---------|---------|------|---------| +| **-u-** | de | appartenant Ă  (= "no" japonais) | nak-**u**-ura = enfant de l'eau | +| **-ui-** | pour | destinĂ© Ă , au service de | tal-**ui**-savu = hall pour les serments | + +**Usage** : Possession, affiliation, destination + +#### Domaine A : Relation (avec, ensemble) + +| Liaison | Concept | Sens | Exemple | +|---------|---------|------|---------| +| **-a-** | avec | ensemble, accompagnĂ© | or-**a**-umi = aurore avec esprit | +| **-aa-** | mĂ©lange | mĂȘlĂ© Ă , confluent, fusionnĂ© | ur-**aa**-kota = eau mĂȘlĂ©e Ă  l'union | +| **-ae-** | Ă©gal | Ă©quivalent Ă , au mĂȘme niveau | tor-**ae**-kasi = personne Ă©gale au chef | +| **-ao-** | domine | supĂ©rieur Ă , vainqueur | ak-**ao**-zana = faucon vainqueur | + +**Usage** : Relations sociales, hiĂ©rarchies, fusion de concepts + +#### Domaine O : Tension (contre, obstacle) + +| Liaison | Concept | Sens | Exemple | +|---------|---------|------|---------| +| **-o-** | obstacle | face Ă , contre, confrontation | kor-**o**-oki = cƓur face au danger | +| **-oa-** | rĂ©solu | surmontĂ©, accompli, vaincu | ak-**oa**-zana = faucon ayant vaincu | + +**Usage** : Conflit, dĂ©fi, rĂ©solution + +#### Domaine E : Dimension temporelle/spatiale + +| Liaison | Concept | Sens | Exemple | +|---------|---------|------|---------| +| **-e-** | source | origine, passĂ©, cause | nek-**e**-seka = faire-origine du savoir | +| **-ei-** | centre | prĂ©sent, ici, actuel | lok-**ei**-tisa = lieu-ici, cet endroit | +| **-ea-** | direction | futur, but, destination | tek-**ea**-kota = chemin vers l'union | +| **-eo-** | totalitĂ© | Ă©ternel, universel, absolu | sil-**eo**-veri = regard Ă©ternel/vĂ©ritĂ© | + +**Usage** : TemporalitĂ©, causalitĂ©, spatialitĂ© abstraite + +--- + +## Exemples de composition dĂ©taillĂ©s + +### Exemple 1 : Siliaska (Le peuple) + +``` +COMPOSITION : sil-i-aska + +ÉTYMOLOGIE : +├─ sili (regard, Ɠil, vision) +│ └─ racine standard (observation) +├─ -i- (agent actif) +│ └─ "celui qui porte, qui fait" +└─ aska (libre, libertĂ©) + └─ racine sacrĂ©e (concept fondateur) + +SENS LITTÉRAL : "Porteurs du regard libre" +SENS CULTUREL : Le peuple de la Confluence, caractĂ©risĂ© par + son regard libre acquis par le pĂšlerinage + au Gouffre Humide + +ANALYSE MORPHOLOGIQUE : +- Type : Nom ethnique (peuple) +- Structure : standard-liaison-sacrĂ©e (courant) +- Longueur : 8 lettres, 4 syllabes +- Euphonie : si-li-as-ka (liquide + fricative + vĂ©laire) +``` + +### Exemple 2 : Uraakota (La Confluence) + +``` +COMPOSITION : ur-aa-kota + +ÉTYMOLOGIE : +├─ ura (eau, fluide) +│ └─ racine sacrĂ©e (Ă©lĂ©ment primordial) +├─ -aa- (mĂ©lange, fusion) +│ └─ "mĂȘlĂ© Ă , confluent" +└─ kota (union, ensemble, confluence) + └─ racine standard (relation) + +SENS LITTÉRAL : "Eau-fusion-union" +SENS CULTUREL : Le lieu de confluence des deux riviĂšres, + centre spirituel et politique, + capitale de la civilisation + +ANALYSE MORPHOLOGIQUE : +- Type : Nom propre (lieu) +- Structure : sacrĂ©e-liaison-standard (rare, valorisĂ©e) +- Longueur : 8 lettres, 5 syllabes +- Euphonie : u-ra-a-ko-ta (dominante vocalique postĂ©rieure) +- Symbolisme : La double voyelle "aa" mime le flux d'eau +``` + +### Exemple 3 : Nakukeko (Enfants des Échos) + +``` +COMPOSITION : nak-u-keko + +ÉTYMOLOGIE : +├─ naki (enfant, descendant) +│ └─ racine standard (relation familiale) +├─ -u- (appartenance) +│ └─ "de, appartenant Ă " +└─ keko (Ă©cho, rĂ©sonance) + └─ racine standard (phĂ©nomĂšne acoustique) + +SENS LITTÉRAL : "Enfants de l'Ă©cho" +SENS CULTUREL : Caste des habitants souterrains, + pĂąles, adaptĂ©s aux grottes, + maĂźtres carriers et sculpteurs + +ANALYSE MORPHOLOGIQUE : +- Type : Nom de caste +- Structure : standard-liaison-standard (courant) +- Longueur : 8 lettres, 4 syllabes +- Euphonie : na-ku-ke-ko (rĂ©pĂ©tition k, mime l'Ă©cho) +- Symbolisme : La structure rĂ©pĂ©titive Ă©voque la rĂ©verbĂ©ration +``` + +### Exemple 4 : Akoazana (Faucons Chasseurs) + +``` +COMPOSITION : ak-oa-zana + +ÉTYMOLOGIE : +├─ aki (faucon) +│ └─ racine sacrĂ©e (animal sacrĂ©) +├─ -oa- (rĂ©solution, vaincu) +│ └─ "surmontĂ©, accompli, vainqueur" +└─ zana (chasser, traquer) + └─ racine standard (action de chasse) + +SENS LITTÉRAL : "Faucon-vainqueur-chasseur" +SENS CULTUREL : Élite militaire, judiciaire et religieuse, + basĂ©s dans les Halls des Serments, + guerriers d'Ă©lite + +ANALYSE MORPHOLOGIQUE : +- Type : Nom de caste +- Structure : sacrĂ©e-liaison-standard (valorisĂ©e) +- Longueur : 8 lettres, 4 syllabes +- Euphonie : a-ko-a-za-na (dominante vocalique antĂ©rieure) +- Symbolisme : -oa- exprime la maĂźtrise de la chasse +``` + +### Exemple 5 : Oraumi (Voix de l'Aurore) + +``` +COMPOSITION : or-a-umi + +ÉTYMOLOGIE : +├─ ora (aurore, aube) +│ └─ racine sacrĂ©e (moment sacrĂ©) +├─ -a- (avec, ensemble) +│ └─ "accompagnĂ© de" +└─ umi (esprit, souffle vital) + └─ racine sacrĂ©e (concept spirituel) + +SENS LITTÉRAL : "Aurore-avec-esprit" +SENS CULTUREL : Chamans gardiens des lois anciennes, + menĂ©s par les Ailes-Grises, + guides spirituels de la civilisation + +ANALYSE MORPHOLOGIQUE : +- Type : Nom de caste +- Structure : sacrĂ©e-liaison-sacrĂ©e (RARE, trĂšs valorisĂ©e) +- Longueur : 6 lettres, 4 syllabes +- Euphonie : o-ra-u-mi (liquide + voyelles ouvertes) +- Symbolisme : Double racine sacrĂ©e = statut spirituel Ă©levĂ© +``` + +--- + +## RĂšgles de composition avancĂ©es + +### Composition multiple (3+ Ă©lĂ©ments) + +Il est possible de composer plus de deux racines, mais c'est **rare** : + +``` +STRUCTURE : racine₁-liaison₁-racine₂-liaison₂-racine₃ + +Exemple thĂ©orique : +sil-i-ask-u-tori += porteur-du-regard-libre-personne += "Personne ayant le regard libre" + +⚠ En pratique : Éviter les compositions de 3+ Ă©lĂ©ments + car elles deviennent trop longues et difficiles Ă  prononcer. + PrĂ©fĂ©rer : siliaska tori (juxtaposition) +``` + +### Composition avec racines identiques + +Possible mais rare, crĂ©e un effet d'emphase : + +``` +ur-aa-ura = eau-fusion-eau = "Grande eau", ocĂ©an +sil-i-sili = regard-actif-regard = "Regard intense" +``` + +### Collision vocalique (hiatus) + +Quand une liaison se termine par une voyelle et la racine 2 commence par une voyelle : + +``` +PROBLÈME : ur-aa-ura → ur-aa-ura (a-u hiatus) +SOLUTION : Accepter l'hiatus (prononciation distincte) + +Prononciation : [u-ra-a-u-ra] +Pas de fusion : ur-aura ❌ +Pas d'Ă©lision : ur-aa-ra ❌ +``` + +### Ordre des Ă©lĂ©ments + +**Principe gĂ©nĂ©ral** : Le modifiĂ© prĂ©cĂšde le modifiant + +``` +✅ CORRECT +sil-i-aska = regard-AGENT-libre += "Celui qui porte le regard libre" +(le regard est l'Ă©lĂ©ment central, la libertĂ© le qualifie) + +nak-u-ura = enfant-DE-eau += "Enfant de l'eau" +(l'enfant est l'Ă©lĂ©ment central, l'eau l'origine) + +❌ INCORRECT (sens inversĂ©) +ask-i-sili = libre-AGENT-regard += "Celui qui porte la libertĂ© du regard" (sens diffĂ©rent) +``` + +### Forme liĂ©e systĂ©matique + +**RĂšgle absolue** : La racine 1 passe TOUJOURS en forme liĂ©e (perte voyelle finale) + +``` +sili → sil- +aska → ask- +ura → ur- +naki → nak- +kota → kot- + +JAMAIS : +sili-i-aska ❌ +ura-aa-kota ❌ +``` + +--- + +## Morphologie verbale + +Les verbes mĂ©ritent une section Ă  part car leur morphologie est distincte. + +### Forme infinitive (CVCVC) + +Les verbes sont des **racines modifiĂ©es** qui prennent une consonne finale : + +| Racine (CV) | Verbe (CVC) | Suffixe | Exemple | +|-------------|-------------|---------|---------| +| mira | mir-ak | -k | voir | +| neka | nek-an | -n | faire | +| vosa | vos-ak | -k | dire | +| teki | tek-is | -s | aller | +| kisu | kis-un | -n | transmettre | + +**Suffixes verbaux** : +- **-k** : verbes d'observation/perception (mirak, pasak, vosak) +- **-n** : verbes d'action/crĂ©ation (nekan, kitan, kisun) +- **-s** : verbes de mouvement (tekis, mokis, zakis) +- **-m** : verbes de connaissance (sekam) + +### Verbe + Conjugateur + +Les verbes ne se conjuguent **jamais** par flexion interne. Ils restent invariables et prennent des **conjugateurs suffixĂ©s** : + +``` +STRUCTURE : VERBE + CONJUGATEUR + +mirak + u → miraku (je vois, prĂ©sent) +mirak + at → mirakat (j'ai vu, passĂ©) +mirak + en → mirakem (je verrai, futur) +``` + +Voir **03-GRAMMAIRE.md** pour la liste complĂšte des conjugateurs. + +--- + +## Morphologie dĂ©rivationnelle + +### Nominalisation (racine → nom d'action) + +On peut crĂ©er un nom d'action Ă  partir d'une racine verbale : + +``` +RACINE VERBALE → NOM D'ACTION +mira (voir) → mira + seka (savoir) → miraseka (observation) +neka (faire) → neka + tava (travail) → nekatava (crĂ©ation) +``` + +⚠ **Attention** : Pas de suffixe dĂ©rivatif "-tion", "-ment", etc. + On utilise la **composition** avec des racines appropriĂ©es. + +### Adjectivisation (racine → qualitĂ©) + +Le Confluent n'a pas d'adjectifs au sens traditionnel. On utilise : + +1. **Composition avec liaison -a-** (avec) : + ``` + kori-a-suki = cƓur-avec-feu = "colĂ©rique" + sili-a-veri = regard-avec-vĂ©ritĂ© = "clairvoyant" + ``` + +2. **Juxtaposition** : + ``` + tori mako = personne grande = "grande personne" + ura nisa = eau humide = "eau humide" (plĂ©onasme rare) + ``` + +### Adverbialisation (racine → maniĂšre) + +Pas d'adverbes morphologiques (-ment). Utiliser : + +1. **Composition avec liaison -e-** (origine/cause) : + ``` + nek-e-tosa = faire-avec-bontĂ© = "bien fait" + vos-e-veri = dire-avec-vĂ©ritĂ© = "dire vraiment" + ``` + +2. **Particule instrumentale "vu"** : + ``` + vu kori tosa = avec cƓur bon = "avec bontĂ©" + ``` + +--- + +## Morphologie diachronique + +### Évolution Proto → Ancien → Classique + +| Stade | Structure racine | Liaisons | Verbes | +|-------|------------------|----------|--------| +| **Proto-Confluent** | CV strict | Pas de liaisons | Racines verbales CV | +| **Ancien Confluent** | CV (racines), CVC (verbes) | 16 liaisons sacrĂ©es | Verbes CVCVC + conjugateurs | +| **Classique** (futur) | CV + diphtongues | 16+ liaisons Ă©tendues | Verbes + aspects complexes | + +### Innovations morphologiques rĂ©centes + +Le systĂšme actuel (Ancien Confluent) a introduit : + +1. **Distinction verbe/nom** par la finale (C vs V) +2. **16 liaisons sacrĂ©es** codifiĂ©es (auparavant juxtaposition) +3. **Conjugateurs** sĂ©parĂ©s du radical verbal + +--- + +## ProductivitĂ© morphologique + +### RĂšgles de crĂ©ation de nouveaux mots + +Pour crĂ©er un nouveau mot en respectant le systĂšme : + +1. **Identifier le concept** Ă  exprimer +2. **Choisir 2 racines** existantes pertinentes +3. **SĂ©lectionner la liaison** appropriĂ©e +4. **VĂ©rifier l'euphonie** (Ă©viter 3 consonnes, hiatus difficiles) +5. **Valider la transparence** (Ă©tymologie claire ?) + +**Exemple de crĂ©ation** : + +``` +BESOIN : "forgeron" (travailleur du mĂ©tal) + +ANALYSE : +- metu (mĂ©tal) + tava (travail) + agent +- met- + -i- + tava + +RÉSULTAT : metitava (forgeron) +DÉCOMPOSITION : met-i-tava = mĂ©tal-agent-travail + +VALIDATION : +✅ Euphonie : me-ti-ta-va (4 syllabes CV) +✅ Transparence : "celui qui travaille le mĂ©tal" +✅ Ratio : standard-liaison-standard (acceptable) +``` + +--- + +## Annexe : Index morphologique + +### Racines par frĂ©quence dans compositions + +Top 10 des racines les plus composĂ©es : + +1. **sili** (regard) : siliaska, silietiku, siliaveri... +2. **naki** (enfant) : nakuura, nakukeko, nakiumita... +3. **ura** (eau) : uraakota, vukuura, nakuura... +4. **kota** (union) : uraakota, kekutoka... +5. **aska** (libre) : siliaska, aliaska... +6. **aki** (faucon) : akoazana... +7. **ora** (aurore) : oraumi... +8. **umi** (esprit) : oraumi... +9. **keko** (Ă©cho) : nakukeko, kekutoka... +10. **vela** (vigile) : sikuvela... + +### Liaisons par frĂ©quence d'usage + +1. **-u-** (appartenance) : 40% des compositions (nakuura, vukuura...) +2. **-i-** (agent) : 25% (siliaska, takitosa...) +3. **-a-** (avec) : 15% (oraumi, ekakova...) +4. **-aa-** (fusion) : 10% (uraakota...) +5. Autres : 10% + +--- + +*Document linguistique - Civilisation de la Confluence* +*Voir aussi : 03-GRAMMAIRE.md pour le systĂšme verbal complet* diff --git a/docs/langue/03-GRAMMAIRE.md b/docs/langue/03-GRAMMAIRE.md new file mode 100644 index 0000000..8751da7 --- /dev/null +++ b/docs/langue/03-GRAMMAIRE.md @@ -0,0 +1,558 @@ +# 03 - GRAMMAIRE DU CONFLUENT + +La grammaire du Confluent est un systĂšme **transparent et rĂ©gulier** qui reflĂšte la vision multi-gĂ©nĂ©rationnelle de la civilisation. Chaque Ă©lĂ©ment grammatical a Ă©tĂ© pensĂ© pour exprimer non seulement le temps, mais aussi **la mĂ©moire, la transmission et la continuitĂ©**. + +--- + +## Philosophie grammaticale + +La grammaire du Confluent repose sur trois principes : + +1. **Transparence** : Chaque Ă©lĂ©ment grammatical est un morphĂšme sĂ©parĂ© et visible +2. **RĂ©gularitĂ©** : Aucune exception, aucune conjugaison irrĂ©guliĂšre +3. **Profondeur temporelle** : 4 niveaux de passĂ© reflĂštent la mĂ©moire culturelle + +--- + +## Classes de mots + +### Distinction nom/verbe + +Le Confluent distingue noms et verbes par leur **finale** : + +| Classe | Finale | Structure | Exemples | +|--------|--------|-----------|----------| +| **Noms/Racines** | Voyelle | ...CV | sili, aska, kota, naki | +| **Verbes** | Consonne | CVCVC | mirak, nekan, vosak, kisun | + +Cette distinction est **absolue** et permet d'identifier immĂ©diatement la classe d'un mot. + +### Autres classes + +Le Confluent n'a pas de classes fermĂ©es rigides, mais plutĂŽt des **fonctions** : + +- **Particules** : invariables, marquent les fonctions syntaxiques +- **Pronoms** : 3 formes fixes (miki, sinu, tani) +- **DĂ©monstratifs** : 2 racines (tisa/tova) + compositions +- **Nombres** : base 12, systĂšme additionnel + +**Pas d'adjectifs, pas d'adverbes** : Ces fonctions sont assurĂ©es par composition de racines ou particules. + +--- + +## SystĂšme verbal + +### Les 12 verbes de base (hĂ©ritage Proto-Confluent) + +| Verbe | Sens | Racine | Usage | +|-------|------|--------|-------| +| **mirak** | voir, observer | mira | Perception visuelle | +| **tekis** | aller, voyager | teki | Mouvement | +| **kitan** | donner, offrir | kita | Transfert | +| **pasak** | prendre, saisir | pasa | Acquisition | +| **nekan** | faire, crĂ©er | neka | Action crĂ©ative | +| **vosak** | dire, parler | vosa | Communication | +| **sekam** | savoir, connaĂźtre | seka | Connaissance | +| **mokis** | apprendre | moki | Acquisition savoir | +| **kisun** | transmettre, enseigner | kisu | Transmission | +| **zakis** | garder, protĂ©ger | zaki | Protection | +| **takan** | porter, transporter | taka | Portage | +| **zanak** | chasser, traquer | zana | Chasse | + +**Extension moderne** : Le lexique actuel compte **36 verbes** supplĂ©mentaires (voir lexique.json). + +### Verbes spirituels importants + +| Verbe | Sens | Racine | Contexte | +|-------|------|--------|----------| +| **umiak** | mĂ©diter | umi | Pratique spirituelle | +| **asavik** | prier | asa | Rituel sacrĂ© | +| **vokis** | invoquer | voki | Appel aux esprits | +| **tosan** | bĂ©nir | tosa | BĂ©nĂ©diction | +| **kotam** | communier | kota | Union spirituelle | +| **osian** | mourir | osi | Passage vers ancĂȘtres | + +--- + +## Conjugaison : systĂšme de conjugateurs + +Le Confluent **n'a pas de conjugaison par flexion**. Le verbe reste invariable et prend des **conjugateurs suffixĂ©s**. + +**Structure** : `VERBE + CONJUGATEUR` + +``` +mirak + u → miraku (je vois - prĂ©sent) +mirak + at → mirakat (j'ai vu - passĂ© vĂ©cu) +mirak + en → mirakem (je verrai - futur) +``` + +### Conjugateurs de temps (6) + +Les conjugateurs de temps sont au cƓur de la vision multi-gĂ©nĂ©rationnelle. + +| Conjugateur | Sens | DurĂ©e | Exemple | Contexte | +|-------------|------|-------|---------|----------| +| **u** | PrĂ©sent neutre | Maintenant | miraku | Action en cours | +| **at** | PassĂ© vĂ©cu | Ma vie | mirakat | J'ai vu de mes yeux | +| **aan** | PassĂ© regrettĂ© | Ma vie | mirakaan | J'ai vu (et je regrette) | +| **ait** | PassĂ© ancestral | LignĂ©e | mirakait | Nos ancĂȘtres ont vu | +| **amat** | PassĂ© mythique | Temps premiers | mirakamat | Les Premiers ont vu | +| **en** | Futur | À venir | mirakem | Je verrai | + +#### Les 4 passĂ©s : philosophie de la mĂ©moire + +Le Confluent possĂšde **4 niveaux de passĂ©**, reflĂ©tant l'importance culturelle de la transmission : + +**1. PassĂ© vĂ©cu (at)** : "Dans ma vie" +``` +Va miki vo aita mirakat += J'ai vu l'ancĂȘtre (de mes yeux) +``` + +**2. PassĂ© regrettĂ© (aan)** : "HĂ©las, dans ma vie" +``` +Va miki vo tori nekaan += J'ai crĂ©Ă© la personne (erreur, regret) +``` +- Usage : Actions malheureuses, erreurs, regrets +- Marque la **rĂ©flexivitĂ©** et **l'apprentissage par l'erreur** + +**3. PassĂ© ancestral (ait)** : "Temps de nos ancĂȘtres" +``` +Va aita su vo seka kisunit += Les ancĂȘtres ont transmis le savoir +``` +- Usage : Savoirs transmis, traditions, lois +- Marque la **lĂ©gitimitĂ© par la lignĂ©e** + +**4. PassĂ© mythique (amat)** : "Temps des Premiers AncĂȘtres" +``` +Va ena su vo Uraakota nekamat += Les Premiers ont crĂ©Ă© La Confluence +``` +- Usage : Mythes, cosmogonie, temps sacrĂ©s +- Marque **l'origine absolue**, le temps cĂ©rĂ©moniel + +Cette stratification temporelle reflĂšte la vision de la civilisation : le savoir s'accumule gĂ©nĂ©ration aprĂšs gĂ©nĂ©ration, comme les couches de la Grande Fresque. + +### Conjugateurs d'aspect (4) + +Les aspects modifient la **maniĂšre** dont l'action se dĂ©roule. + +| Conjugateur | Sens | Description | Exemple | +|-------------|------|-------------|---------| +| **il** | Accompli | Action terminĂ©e, rĂ©sultat permanent | mirakil (avoir vu complĂštement) | +| **eol** | Habituel | Action rĂ©guliĂšre, rĂ©pĂ©tĂ©e | mirakeol (voir habituellement) | +| **eon** | Cyclique | Action qui revient (saisons) | mirakeon (voir cycliquement) | +| **eom** | Éternel | Action immuable, hors du temps | mirakeom (voir Ă©ternellement) | + +**Exemples culturels** : + +``` +Va sora tekiseon += Le soleil va cycliquement (lever quotidien) + +Va aita su vo seka kisuneom += Les ancĂȘtres transmettent Ă©ternellement le savoir +(transmission perpĂ©tuelle) + +Va naki vo aita mirakeol += L'enfant voit habituellement l'ancĂȘtre +(rituel rĂ©gulier) +``` + +### Conjugateurs de mode (3) + +Les modes expriment l'**attitude** du locuteur envers l'action. + +| Conjugateur | Sens | Usage | Exemple | +|-------------|------|-------|---------| +| **ok** | ImpĂ©ratif | Ordre, commande | mirakok (vois !) | +| **es** | Souhait | DĂ©sir, espoir | mirakes (puissĂ©-je voir) | +| **ul** | CapacitĂ© | Pouvoir, aptitude | mirakul (pouvoir voir) | + +**Exemples** : + +``` +Miratok! += Regarde ! (ordre direct) + +Va miki vo uraakota mirakes += PuissĂ©-je voir la Confluence (souhait de pĂšlerinage) + +Va siliaska vo veri mirakul += Les Siliaska peuvent voir la vĂ©ritĂ© (capacitĂ© acquise) +``` + +### Conjugateur Ă©videntiel (1) + +L'Ă©videntiel marque la **source de l'information**. + +| Conjugateur | Sens | Usage | Exemple | +|-------------|------|-------|---------| +| **uv** | C'est Ă©crit | Source textuelle, archives | mirakuv (il est Ă©crit qu'on a vu) | + +**Contexte culturel** : L'Ă©videntiel -uv est crucial pour une civilisation qui valorise les **archives sur glyphes**. Il marque qu'une information provient d'une source Ă©crite, donc vĂ©rifiable et transmissible. + +``` +Va aita su vo Vukuura nekanuv += Les ancĂȘtres ont crĂ©Ă© le Gouffre Humide (c'est Ă©crit) +(rĂ©fĂ©rence aux tablettes d'argile) +``` + +### Combinaisons de conjugateurs + +**RĂšgle** : On peut combiner **temps + aspect** ou **temps + mode**, mais pas **aspect + mode**. + +``` +✅ COMBINAISONS VALIDES +mirakat + il → mirakatil (j'ai vu complĂštement - passĂ© accompli) +mirakem + es → mirakemes (je souhaiterai voir - futur souhait) +miraku + eol → mirakueol (je vois habituellement - prĂ©sent habituel) + +❌ COMBINAISONS INVALIDES +mirakil + es (accompli + souhait) +mirakeol + ok (habituel + impĂ©ratif) +``` + +**Ordre** : VERBE + TEMPS + ASPECT/MODE + +``` +mirak + at + il → mirakatil +(voir + passĂ© + accompli) += "J'ai complĂštement vu" +``` + +--- + +## Pronoms personnels (3) + +Le Confluent possĂšde **3 pronoms** de base, sans distinction de genre. + +| Pronom | Sens | Personne | Exemple | +|--------|------|----------|---------| +| **miki** | je, moi | 1sg | va miki miraku | +| **sinu** | tu, toi | 2sg | va sinu miraku | +| **tani** | il, elle, iel | 3sg | va tani miraku | + +**Pas de pluriel pronominal** : Utiliser le pluriel **su** : +``` +va miki su = nous (littĂ©ralement "je-pluriel") +va sinu su = vous +va tani su = ils/elles/iels +``` + +**Pas de distinction de genre** : Le pronom **tani** est neutre et s'applique Ă  tous les genres. Cela reflĂšte la vision Ă©galitaire de la Confluence. + +**Pas de vouvoiement** : Le Confluent n'a pas de forme de politesse pronominale. Le respect s'exprime par : +- Le choix des verbes (bĂ©nir, honorer) +- Les titres et castes (Akoazana, Aliaska) +- Les particules honorifiques (Ă  dĂ©velopper) + +--- + +## DĂ©monstratifs (2) + +Le Confluent possĂšde **2 racines dĂ©monstratives** : + +| Racine | Sens | Distance | Exemple | +|--------|------|----------|---------| +| **tisa** | ici, proche, prĂ©sent | ProximitĂ© | tisa tori = cette personne-ci | +| **tova** | lĂ -bas, loin, distant | Éloignement | tova tori = cette personne-lĂ  | + +**Compositions** : +``` +tis-i-loku = cet-endroit-ci (lieu proximal) +tov-i-loku = cet-endroit-lĂ  (lieu distal) +tis-i-naki = cet-enfant-ci +tov-i-naki = cet-enfant-lĂ  +``` + +**Usage temporel** (extension moderne) : +``` +tisa = maintenant, ce moment (temps proximal) +tova = alors, ce moment-lĂ  (temps distal) +``` + +--- + +## SystĂšme de nombres (Base 12) + +Le Confluent utilise la **base 12** (dodĂ©cimale), basĂ©e sur : +- **12 phalanges** sur 4 doigts (comptage corporel) +- **12 cycles lunaires** par annĂ©e (cosmologie) + +### Chiffres de base (0-12) + +| Base 10 | Base 12 | Confluent | Forme liĂ©e | +|---------|---------|-----------|------------| +| 0 | 0 | **zaro** | zar- | +| 1 | 1 | **iko** | ik- | +| 2 | 2 | **diku** | dik- | +| 3 | 3 | **tiru** | tir- | +| 4 | 4 | **katu** | kat- | +| 5 | 5 | **penu** | pen- | +| 6 | 6 | **seku** | sek- | +| 7 | 7 | **sivu** | siv- | +| 8 | 8 | **oktu** | okt- | +| 9 | 9 | **novu** | nov- | +| 10 | A | **deku** | dek- | +| 11 | B | **levu** | lev- | +| 12 | 10 | **tolu** | tol- | + +### Puissances de 12 + +| Valeur (base 10) | Base 12 | Confluent | Composition | +|------------------|---------|-----------|-------------| +| 12 | 10 | **tolu** | douzaine | +| 144 | 100 | **tolusa** | tol-u-sa (grosse) | +| 1728 | 1000 | **toluaa** | tol-aa-tol (confluence de douzaines) | +| 20736 | 10000 | **tolumako** | tol-u-mako (grande douzaine) | + +### Construction des nombres + +**Structure** : COEFFICIENT + tolu + UNITÉ + +``` +13 (base 10) = 1×12 + 1 = "11" (base 12) +→ tolu iko (douze-un) + +25 (base 10) = 2×12 + 1 = "21" (base 12) +→ diku tolu iko (deux-douze-un) + +37 (base 10) = 3×12 + 1 = "31" (base 12) +→ tiru tolu iko (trois-douze-un) + +144 (base 10) = 12ÂČ = "100" (base 12) +→ tolusa (grosse) + +156 (base 10) = 144 + 12 = "110" (base 12) +→ tolusa tolu (grosse-douze) +``` + +### Quantificateurs vagues + +Le Confluent utilise aussi des **quantificateurs approximatifs** : + +| Expression | Sens | Usage | +|------------|------|-------| +| **tiru tiru** | quelques | RĂ©pĂ©tition de "trois" | +| **tolu tolu** | beaucoup | RĂ©pĂ©tition de "douze" | +| **mako** | grand nombre | Racine "grand" | +| **pisu** | petit nombre | Racine "petit" | + +``` +Va tiru tiru naki tekisu += Quelques enfants vont (3-3 enfants) + +Va tolu tolu apo miraku += Beaucoup d'oiseaux voient (12-12 oiseaux) +``` + +### OpĂ©rations arithmĂ©tiques (vocabulaire) + +| OpĂ©ration | Verbe | Exemple | +|-----------|-------|---------| +| Compter | **toluk** | Compter en base 12 | +| Additionner | **samuk** | Assembler (samu + -k) | +| Soustraire | **pasak** | Prendre (retirer) | +| Multiplier | **mikuaa** | MĂ©langer-fusion (miku + -aa-) | +| Diviser | **kisun** | Partager (transmettre) | + +--- + +## Particules grammaticales + +Les particules sont des **morphĂšmes invariables** qui marquent les fonctions syntaxiques. Voir **04-SYNTAXE.md** pour leur usage dĂ©taillĂ©. + +### Particules de cas (avant le nom) + +| Particule | Fonction | Équivalent français | +|-----------|----------|---------------------| +| **va** | Sujet | (sujet de la phrase) | +| **vo** | Objet direct | (complĂ©ment d'objet) | +| **vi** | Direction | vers, Ă  | +| **ve** | Origine | de, depuis | +| **vu** | Instrument | avec, au moyen de | +| **na** | Possession | de (appartenance) | +| **ni** | BĂ©nĂ©ficiaire | pour, Ă  l'intention de | +| **no** | Lieu | dans, Ă  (localisation) | + +### Particules de nĂ©gation (avant le verbe) + +| Particule | Sens | Usage | +|-----------|------|-------| +| **zo** | ne...pas | NĂ©gation standard | +| **zom** | jamais | NĂ©gation temporelle absolue | +| **zob** | interdit | NĂ©gation modale (prohibition) | +| **zoe** | pas vraiment | NĂ©gation attĂ©nuĂ©e | + +### Particules interrogatives + +| Particule | Sens | Position | +|-----------|------|----------| +| **ka** | est-ce que ? | Fin de phrase | +| **ki** | qui ? | Remplace le sujet/objet | +| **ke** | quoi ? | Remplace l'objet | +| **ko** | oĂč ? | Remplace le lieu | +| **ku** | quand ? | Remplace le temps | + +### Particule de pluriel + +| Particule | Sens | Position | +|-----------|------|----------| +| **su** | pluriel | **APRÈS** le nom | + +**⚠ IMPORTANT** : Contrairement aux autres particules, **su** se place **aprĂšs** le nom. + +``` +✅ CORRECT +va naki su = les enfants (SUJET) +vo apo su = les oiseaux (OBJET) + +❌ INCORRECT +va su naki +vo su apo +``` + +--- + +## Connecteurs logiques + +Le Confluent possĂšde des **connecteurs** pour relier les propositions. + +| Connecteur | Sens | Type | Position | +|------------|------|------|----------| +| **ti** | et | Coordination | Entre Ă©lĂ©ments | +| **bo** | mais | Opposition | DĂ©but phrase 2 | +| **po** | ou | Alternative | Entre options | +| **lo** | donc | ConsĂ©quence | DĂ©but phrase 2 | +| **se** | car, parce que | Cause | DĂ©but phrase 2 | +| **me** | si | Condition | DĂ©but condition | +| **ne** | alors | RĂ©sultat conditionnel | DĂ©but rĂ©sultat | + +**Exemples** : + +``` +Va miki miraku ti va sinu tekisu += Je vois et tu vas + +Va miki miraku. Bo va sinu zo miraku. += Je vois. Mais tu ne vois pas. + +Me va miki miraku, ne va miki vosaku += Si je vois, alors je parle +``` + +--- + +## Émotions : mĂ©taphores corporelles + +Le Confluent **n'a pas de mots abstraits pour les Ă©motions**. Il utilise des **mĂ©taphores corporelles**. + +### Racines corporelles Ă©motionnelles + +| Racine | Sens | Usage Ă©motionnel | +|--------|------|------------------| +| **kori** | cƓur | Centre Ă©motionnel | +| **sili** | regard | Perception/conscience | +| **kina** | sang | IntensitĂ©/vitalitĂ© | +| **puli** | souffle | AnxiĂ©tĂ©/calme | + +### MĂ©taphores simples (2 mots) + +**Usage quotidien** : Juxtaposition de deux racines + +| Expression | Traduction littĂ©rale | Sens | +|------------|---------------------|------| +| **kori sora** | cƓur-soleil | Joie | +| **kori taku** | cƓur-sombre | Tristesse | +| **sili taku** | regard-obscur | Peur | +| **kina suki** | sang-feu | ColĂšre | +| **kori ura** | cƓur-eau | Calme | +| **sili ura** | regard-fluide | CuriositĂ© | + +**Exemple** : +``` +Va miki kori sora += Mon cƓur (est) soleil +→ Je suis joyeux +``` + +### Compositions formelles (avec liaisons) + +**Usage formel/rituel** : Composition avec liaison -a- (avec) ou -o- (contre) + +| Composition | DĂ©composition | Sens | +|-------------|---------------|------| +| **koriasora** | kor-a-sora | Joie (cƓur avec soleil) | +| **koriataku** | kor-a-taku | Tristesse (cƓur avec sombre) | +| **siliataku** | sil-a-taku | Peur (regard avec sombre) | +| **koriasuki** | kor-a-suki | ColĂšre (cƓur avec feu) | +| **koriakota** | kor-a-kota | Amour (cƓur avec union) | +| **koriaura** | kor-a-ura | SĂ©rĂ©nitĂ© (cƓur avec eau) | +| **koriooki** | kor-o-oki | Angoisse (cƓur contre danger) | + +**Liaisons utilisĂ©es** : +- **-a-** (avec) : Émotions positives/neutres +- **-o-** (contre) : Confrontation, tension +- **zo** (nĂ©gation) : Privation (ex: korizoora = dĂ©sespoir, "cƓur sans aurore") + +**Exemple formel** : +``` +Va aita su vo koriakota kisunit += Les ancĂȘtres ont transmis l'amour (cƓur-avec-union) +``` + +--- + +## RĂ©capitulatif : grammaire en action + +### Phrase simple + +``` +Va naki vo ura miraku + +ANALYSE : +va naki = SUJET (particule + nom) +vo ura = OBJET (particule + nom) +miraku = VERBE (mirak + u prĂ©sent) + +TRADUCTION : L'enfant voit l'eau +``` + +### Phrase complexe + +``` +Va aita su vo seka ni naki su kisunit + +ANALYSE : +va aita su = SUJET (particule + nom + pluriel) +vo seka = OBJET (particule + nom) +ni naki su = BÉNÉFICIAIRE (particule + nom + pluriel) +kisunit = VERBE (kisun + ait passĂ© ancestral) + +TRADUCTION : Les ancĂȘtres ont transmis le savoir aux enfants +``` + +### Phrase avec Ă©motion + +``` +Va miki kori sora. Va miki vo Uraakota mirakait. + +ANALYSE : +Phrase 1: va miki kori sora += Sujet "je" + cƓur-soleil (mĂ©taphore) += "Mon cƓur est soleil" → je suis joyeux + +Phrase 2: va miki vo Uraakota mirakait += Sujet "je" + objet "Confluence" + voir-passĂ© += "J'ai vu la Confluence" + +TRADUCTION : Je suis joyeux. J'ai vu la Confluence. +``` + +--- + +*Document linguistique - Civilisation de la Confluence* +*Voir aussi : 04-SYNTAXE.md pour l'ordre des mots et la construction des phrases* diff --git a/docs/langue/04-SYNTAXE.md b/docs/langue/04-SYNTAXE.md new file mode 100644 index 0000000..0ed3d16 --- /dev/null +++ b/docs/langue/04-SYNTAXE.md @@ -0,0 +1,706 @@ +# 04 - SYNTAXE DU CONFLUENT + +La syntaxe du Confluent reflĂšte la philosophie de **l'observation avant l'action**. Dans une langue oĂč le regard prĂ©cĂšde le geste, l'ordre des mots exprime cette vision : on nomme d'abord ce qu'on observe (sujet, objet), puis on exprime l'action (verbe). + +--- + +## Philosophie syntaxique + +La syntaxe SOV (Sujet-Objet-Verbe) du Confluent n'est pas arbitraire. Elle incarne trois principes culturels : + +1. **Observer avant d'agir** : Nommer les participants avant l'action +2. **PrĂ©parer avant d'exĂ©cuter** : Identifier sujet et objet avant le verbe +3. **RĂ©flĂ©chir avant de parler** : Construction mentale complĂšte avant Ă©nonciation + +--- + +## Ordre des mots : SOV + +### Structure de base + +**Ordre canonique** : SUJET - OBJET - VERBE + +``` +Va naki vo ura miraku +│ │ │ │ └─── VERBE (voir-prĂ©sent) +│ │ │ └──────── OBJET (eau) +│ │ └──────────── Particule objet +│ └───────────────── SUJET (enfant) +└───────────────────── Particule sujet + +TRADUCTION : L'enfant voit l'eau +``` + +### Comparaison avec le français (SVO) + +| Langue | Ordre | Exemple | +|--------|-------|---------| +| **Français** | SVO | L'enfant voit l'eau | +| **Confluent** | SOV | Va naki vo ura miraku | + +Le français place le verbe **entre** sujet et objet. Le Confluent place le verbe **Ă  la fin**, aprĂšs avoir identifiĂ© tous les participants. + +### Justification cognitive + +L'ordre SOV oblige le locuteur Ă  : +1. Identifier le sujet (l'agent) +2. Identifier l'objet (le patient) +3. Choisir le verbe appropriĂ© (l'action) + +Cette sĂ©quence reflĂšte le processus d'**observation mĂ©thodique** valorisĂ© par les Siliaska. + +--- + +## Particules de cas + +Les particules marquent la **fonction syntaxique** des noms dans la phrase. Elles se placent **AVANT** le nom (sauf **su**, le pluriel, qui se place aprĂšs). + +### Particules principales + +| Particule | Fonction | Équivalent | Exemple | +|-----------|----------|------------|---------| +| **va** | Sujet | (sujet) | **va** naki = l'enfant (sujet) | +| **vo** | Objet direct | (COD) | **vo** ura = l'eau (objet) | +| **vi** | Direction | vers, Ă  | **vi** Uraakota = vers la Confluence | +| **ve** | Origine | de, depuis | **ve** toka = de la terre | +| **vu** | Instrument | avec, par | **vu** kanu = avec la main | +| **na** | Possession | de (appartenance) | **na** aita = de l'ancĂȘtre | +| **ni** | BĂ©nĂ©ficiaire | pour, Ă  | **ni** naki = pour l'enfant | +| **no** | Lieu | dans, Ă  | **no** Vukuura = dans le Gouffre | + +### Usage des particules de cas + +#### va : Sujet (agent) + +Marque **celui qui fait l'action**. + +``` +Va tori miraku += La personne voit + +Va aita su kisunit += Les ancĂȘtres ont transmis +``` + +#### vo : Objet direct (patient) + +Marque **ce qui subit l'action**. + +``` +Va naki vo ura miraku += L'enfant voit l'eau + +Va miki vo seka sekamu += Je connais le savoir +``` + +#### vi : Direction (but, destination) + +Marque **vers oĂč** se dirige l'action. + +``` +Va tori vi Uraakota tekisu += La personne va vers la Confluence + +Va miki vi sinu vosaku += Je parle vers toi (je te parle) +``` + +#### ve : Origine (source, provenance) + +Marque **d'oĂč vient** l'action ou l'objet. + +``` +Va naki ve Vukuura tekisu += L'enfant vient du Gouffre Humide + +Va seka ve aita su kisunit += Le savoir vient des ancĂȘtres (a Ă©tĂ© transmis) +``` + +#### vu : Instrument (moyen) + +Marque **avec quoi** l'action est faite. + +``` +Va tori vu kanu vo kari pasaku += La personne prend la pierre avec la main + +Va aita su vu tabi vo seka kisunit += Les ancĂȘtres ont transmis le savoir avec les tablettes +``` + +#### na : Possession (appartenance) + +Marque **Ă  qui appartient** quelque chose. + +``` +Na naki kanu += La main de l'enfant + +Na aita seka += Le savoir de l'ancĂȘtre +``` + +**⚠ DiffĂ©rence avec ve** : +- **na** = possession statique (appartenance) +- **ve** = origine dynamique (provenance) + +``` +Na naki kanu = la main de l'enfant (appartenance) +Ve naki ura = l'eau venant de l'enfant (provenance) +``` + +#### ni : BĂ©nĂ©ficiaire (destinataire) + +Marque **pour qui** l'action est faite. + +``` +Va aita vo seka ni naki kisunit += L'ancĂȘtre a transmis le savoir pour l'enfant + +Va miki ni sinu vo ura kitanu += Je donne l'eau pour toi +``` + +#### no : Lieu (localisation) + +Marque **oĂč** se passe l'action. + +``` +No Uraakota va tori tekisu += À la Confluence, la personne va + +No Vukuura va aita su vo seka kisunit += Dans le Gouffre Humide, les ancĂȘtres ont transmis le savoir +``` + +--- + +## Structure complĂšte de la phrase + +### Ordre canonique complet + +``` +[CIRCONSTANTS] [SUJET] [OBJET] [AUTRES COMPLÉMENTS] [NÉGATION] [VERBE] [CONJUGATEUR] +``` + +**Exemple maximal** : + +``` +No Uraakota va aita su vo seka ni naki su vu tabi zo kisunit + +│ │ │ │ │ │ │ └────── Verbe+temps +│ │ │ │ │ │ └───────── NĂ©gation +│ │ │ │ │ └────────────── Instrument +│ │ │ │ └────────────────── BĂ©nĂ©ficiaire +│ │ │ └──────────────────────────── Objet +│ │ └──────────────────────────────────── Sujet +│ └────────────────────────────────────────────── Circonstant lieu +└────────────────────────────────────────────────────────── Particule lieu + +TRADUCTION : +Dans la Confluence, les ancĂȘtres n'ont pas transmis le savoir +aux enfants avec les tablettes +``` + +### Circonstants (position initiale) + +Les **circonstants** (temps, lieu, maniĂšre) se placent **en dĂ©but de phrase**. + +**Ordre prĂ©fĂ©rĂ©** : TEMPS > LIEU > MANIÈRE + +``` +TEMPS : +Tisa va naki miraku = Maintenant, l'enfant voit +Tova va aita kisunit = Alors, l'ancĂȘtre a transmis + +LIEU : +No Vukuura va naki tekisu = Dans le Gouffre, l'enfant va + +MANIÈRE : +Vu kori tosa va miki vosaku = Avec bontĂ©, je parle +``` + +**Exemple avec plusieurs circonstants** : + +``` +Tisa no Uraakota vu kori tosa va miki vo seka vosaku + +└─┬─┘ └────┬─────┘ └────┬────┘ └─┬──┘ └──┬──┘ └───┬───┘ +TEMPS LIEU MANIÈRE SUJET OBJET VERBE + += Maintenant, Ă  la Confluence, avec bontĂ©, + je parle du savoir +``` + +--- + +## Pluriel : particule su + +**⚠ EXCEPTION IMPORTANTE** : Le pluriel **su** se place **APRÈS** le nom, contrairement aux autres particules. + +``` +✅ CORRECT +va naki su = les enfants (SUJET pluriel) +vo apo su = les oiseaux (OBJET pluriel) +na aita su = des ancĂȘtres (POSSESSION pluriel) + +❌ INCORRECT +va su naki +vo su apo +na su aita +``` + +**Ordre avec particule** : PARTICULE + NOM + **su** + +``` +Va naki su vo ura miraku += Les enfants voient l'eau + +Va tori vo apo su miraku += La personne voit les oiseaux + +Na aita su seka += Le savoir des ancĂȘtres +``` + +--- + +## NĂ©gation + +Les particules de nĂ©gation se placent **AVANT le verbe**. + +### Particules de nĂ©gation + +| Particule | Sens | PortĂ©e | +|-----------|------|--------| +| **zo** | ne...pas | NĂ©gation standard | +| **zom** | jamais | NĂ©gation temporelle absolue | +| **zob** | interdit | NĂ©gation modale (prohibition) | +| **zoe** | pas vraiment | NĂ©gation attĂ©nuĂ©e | + +### Position de la nĂ©gation + +**Ordre** : [SUJET] [OBJET] [**NÉGATION**] [VERBE] + +``` +Va naki vo ura zo miraku += L'enfant ne voit pas l'eau + +Va aita su vo seka zom kisunu += Les ancĂȘtres ne transmettent jamais le savoir (absurde) + +Va miki vi Uraakota zob tekis += Je ne dois pas aller Ă  la Confluence (interdit) +``` + +### NĂ©gation de l'existence + +Pour nier l'existence, utiliser **zo** + verbe existentiel **urak** : + +``` +No Vukuura zo urak += Dans le Gouffre, (cela) n'existe pas + +Va tori zo uraku += La personne n'existe pas +``` + +--- + +## Questions + +Le Confluent possĂšde deux types de questions : **fermĂ©es** (oui/non) et **ouvertes** (qui, quoi, oĂč...). + +### Questions fermĂ©es : particule ka + +La particule **ka** se place **en fin de phrase** pour former une question oui/non. + +``` +Va naki vo ura miraku ka += Est-ce que l'enfant voit l'eau ? + +Va sinu vi Uraakota tekisu ka += Est-ce que tu vas Ă  la Confluence ? +``` + +**RĂ©ponse** : +``` +Question : Va naki miraku ka ? +RĂ©ponse positive : Miraku (il voit) +RĂ©ponse nĂ©gative : Zo miraku (il ne voit pas) +``` + +### Questions ouvertes : pronoms interrogatifs + +Les pronoms interrogatifs **remplacent** l'Ă©lĂ©ment questionnĂ©. + +| Pronom | Sens | Remplace | +|--------|------|----------| +| **ki** | qui ? | Personne (sujet/objet) | +| **ke** | quoi ? | Chose (objet) | +| **ko** | oĂč ? | Lieu | +| **ku** | quand ? | Temps | + +#### ki : qui ? + +``` +Va ki miraku += Qui voit ? (remplace le sujet) + +Va naki vo ki miraku += L'enfant voit qui ? (remplace l'objet) +``` + +#### ke : quoi ? + +``` +Va naki vo ke miraku += L'enfant voit quoi ? + +Va miki ke nekanu += Je fais quoi ? +``` + +#### ko : oĂč ? + +``` +Va naki ko tekisu += L'enfant va oĂč ? + +No ko va tori uraku += Dans quel lieu la personne existe ? +``` + +#### ku : quand ? + +``` +Ku va naki tekisu += Quand l'enfant va-t-il ? +``` + +--- + +## Propositions relatives : limitation du systĂšme + +**⚠ LIMITATION IMPORTANTE** : L'Ancien Confluent **n'a pas de propositions relatives** ("qui", "que", "dont"). + +### StratĂ©gies de contournement + +#### StratĂ©gie 1 : Composition nominale + +**Français** : "Le loup qui chasse" + +**❌ Impossible** : *va zoka i zanak (i n'est pas "qui") + +**✅ Solution** : CrĂ©er une composition ou utiliser juxtaposition + +``` +Option A (composition figĂ©e) : +zokiazana = loup-chasseur (concept figĂ©) + +Option B (juxtaposition) : +Va zoka zanaku = Le loup chasse (phrase sĂ©parĂ©e) +``` + +#### StratĂ©gie 2 : Deux phrases sĂ©parĂ©es + +**Français** : "C'est le collier du loup qui a mangĂ© mon frĂšre" + +**✅ Solution** : SĂ©parer en 2 phrases + +``` +Phrase 1 : Tisikopuu na zoka += C'est le collier du loup + +Phrase 2 : Va zoka vo vaku pasakat += Le loup a pris (mangĂ©) l'ami +``` + +#### StratĂ©gie 3 : Utiliser ve (origine/cause) + +Pour certains cas, **ve** (origine) peut exprimer une relation causale : + +``` +Va tori ve seka (de/par le savoir) +≈ "La personne qui a le savoir" + +Va naki ve Vukuura (de/depuis le Gouffre) +≈ "L'enfant qui vient du Gouffre" +``` + +--- + +## Subordination : connecteurs logiques + +Le Confluent possĂšde des **connecteurs** pour relier les propositions, mais **pas de subordination complexe**. + +### Connecteurs disponibles + +| Connecteur | Sens | Type | Exemple | +|------------|------|------|---------| +| **ti** | et | Coordination | va naki ti va tori = l'enfant et la personne | +| **bo** | mais | Opposition | Va miki miraku. Bo va sinu zo miraku. = Je vois. Mais tu ne vois pas. | +| **po** | ou | Alternative | va naki po va tori = l'enfant ou la personne | +| **lo** | donc | ConsĂ©quence | Va miki miraku. Lo va miki vosaku. = Je vois. Donc je parle. | +| **se** | car | Cause | Va miki vosaku. Se va miki miraku. = Je parle. Car je vois. | +| **me** | si | Condition | Me va miki miraku = Si je vois | +| **ne** | alors | RĂ©sultat | Ne va miki vosaku = Alors je parle | + +### Coordination simple : ti (et) + +``` +Va naki ti va tori vo ura miraku += L'enfant et la personne voient l'eau + +Va miki vo ura ti vo seka miraku += Je vois l'eau et le savoir +``` + +### Opposition : bo (mais) + +**Position** : DĂ©but de la seconde phrase + +``` +Va miki miraku. Bo va sinu zo miraku. += Je vois. Mais tu ne vois pas. +``` + +### Alternative : po (ou) + +``` +Va naki po va tori tekisu ka += L'enfant ou la personne vont-ils ? +``` + +### ConsĂ©quence : lo (donc) + +**Position** : DĂ©but de la seconde phrase + +``` +Va miki vo veri miraku. Lo va miki vosaku. += Je vois la vĂ©ritĂ©. Donc je parle. +``` + +### Cause : se (car, parce que) + +**Position** : DĂ©but de la phrase causale + +``` +Va miki vosaku. Se va miki miraku. += Je parle. Car je vois. +``` + +### Condition : me...ne (si...alors) + +**Structure** : me + CONDITION, ne + RÉSULTAT + +``` +Me va miki miraku, ne va miki vosaku += Si je vois, alors je parle + +Me va naki tekisu, ne va miki kiasoku += Si l'enfant va, alors je suis joyeux +``` + +--- + +## Phrases existentielles + +Pour exprimer l'existence ("il y a"), utiliser le verbe **urak** (ĂȘtre, exister). + +### Construction existentielle + +**Structure** : [LIEU] [SUJET] **urak** + +``` +No Vukuura va aita urak += Dans le Gouffre, il y a un ancĂȘtre + +No Uraakota tiru naki uraku += À la Confluence, il y a trois enfants +``` + +### NĂ©gation existentielle + +``` +No Vukuura zo urak += Dans le Gouffre, il n'y a rien + +Va tori zo uraku += La personne n'existe pas +``` + +--- + +## Phrases avec Ă©motions + +Les Ă©motions s'expriment par **mĂ©taphores corporelles** (voir 03-GRAMMAIRE.md). + +### MĂ©taphore simple (juxtaposition) + +**Structure** : [SUJET] [MÉTAPHORE] + +``` +Va miki kori sora += Moi, cƓur-soleil +→ Je suis joyeux + +Va sinu kori taku += Toi, cƓur-sombre +→ Tu es triste +``` + +### MĂ©taphore formelle (verbe "ĂȘtre") + +``` +Va miki koriasora uraku += Je suis joie (composition kor-a-sora) + +Va aita koriakota uraku += L'ancĂȘtre est amour (composition kor-a-kota) +``` + +--- + +## Phrases rituelles + +Le Confluent possĂšde des **formules rituelles** figĂ©es, souvent utilisĂ©es dans les contextes sacrĂ©s. + +### Formules de salutation (en dĂ©veloppement) + +``` +Va sili aska += Que le regard (soit) libre +(Salutation traditionnelle) + +Va kota tosa += Que l'union (soit) bonne +(Souhait de confluence) +``` + +### Formules de bĂ©nĂ©diction + +``` +Va aita su ni sinu velas += Que les ancĂȘtres veillent sur toi + +Va ora ni sinu tosas += Que l'aurore te bĂ©nisse +``` + +### Formules funĂ©raires + +``` +Va sili ve sinu vi aita su tekis += Que ton regard aille vers les ancĂȘtres + +Va anu ve sinu vi ena tekis += Que ton Ăąme aille vers l'origine +``` + +--- + +## Exemples de phrases complexes annotĂ©es + +### Exemple 1 : Phrase narrative + +``` +No Uraakota va aita su vo seka ni naki su kisunit + +│ └──┬───┘ │ └─┬─┘ │ └┬─┘ │ └─┬─┘ └───┬───┘ +│ LIEU │ SUJET │ OBJ │ BÉNÉF VERBE +│ │ PLU │ │ PLU (transmis-ancestral) +│ │ │ │ +│ Les ancĂȘtres savoir enfants +│ +Dans la Confluence + +TRADUCTION : +À la Confluence, les ancĂȘtres ont transmis le savoir aux enfants +``` + +### Exemple 2 : Phrase conditionnelle + +``` +Me va sinu vi Vukuura tekisu, ne va miki ni sinu vo seka kisunu + +│ │ └──┬┘ │ └──┬───┘ └──┬──┘ │ │ └──┬┘ │ └──┬┘ │ └┬─┘ └──┬──┘ +│ │ SUJET│ LIEU VERBE │ │ SUJET│ BÉNÉF│ OBJ VERBE +│ │ │ (aller) │ │ │ │ (savoir)(transmet) +│ │ │ │ │ │ │ +│ │ toi │ │ moi toi +│ │ │ │ +│ Si Alors +│ +Condition RĂ©sultat + +TRADUCTION : +Si tu vas au Gouffre Humide, alors je te transmets le savoir +``` + +### Exemple 3 : Phrase nĂ©gative avec pluriel + +``` +No Kekutoka va tori su vo apo su zom miraku + +│ └───┬──┘ │ └─┬─┘ │ └┬─┘ │ └───┬───┘ +│ LIEU │ SUJET │ OBJ │ VERBE +│ │ PLU │ PLU │ (jamais voir) +│ │ │ │ +│ personnes oiseaux +│ +Dans Antres des Échos + +TRADUCTION : +Dans les Antres des Échos, les personnes ne voient jamais les oiseaux +(car souterrains) +``` + +### Exemple 4 : Question ouverte + +``` +Va ki vo seka ni naki su kisunit + +│ │ │ └┬─┘ │ └─┬─┘ └───┬───┘ +│ │ │ OBJ │ BÉNÉF VERBE +│ │ │ │ PLU (transmis-ancestral) +│ │ │ │ +│ │ savoir enfants +│ │ +│ Qui ? +│ +SUJET interrogatif + +TRADUCTION : +Qui a transmis le savoir aux enfants ? +``` + +--- + +## Annexe : Ordre des mots comparĂ© + +### Comparaison typologique + +| Langue | Ordre | FrĂ©quence mondiale | Exemple | +|--------|-------|--------------------| --------| +| **Français** | SVO | ~42% | L'enfant voit l'eau | +| **Confluent** | SOV | ~45% | Va naki vo ura miraku | +| **Anglais** | SVO | ~42% | The child sees the water | +| **Japonais** | SOV | ~45% | Ko wa mizu o miru | +| **Arabe** | VSO | ~9% | Yaraa al-tifl al-maa | + +Le Confluent appartient au type **SOV**, le plus rĂ©pandu au monde avec le SVO. + +### Avantages cognitifs du SOV + +1. **PrĂ©paration mentale** : Identifier participants avant l'action +2. **Économie cognitive** : Tous les arguments avant le verbe +3. **FlexibilitĂ©** : Omission du verbe possible (ellipse) +4. **ClartĂ© rĂ©fĂ©rentielle** : Pas d'ambiguĂŻtĂ© sujet/objet (marquage par particules) + +--- + +*Document linguistique - Civilisation de la Confluence* +*Voir aussi : 05-VOCABULAIRE.md pour le lexique complet* diff --git a/docs/langue/05-VOCABULAIRE.md b/docs/langue/05-VOCABULAIRE.md new file mode 100644 index 0000000..23fa4de --- /dev/null +++ b/docs/langue/05-VOCABULAIRE.md @@ -0,0 +1,716 @@ +# 05 - VOCABULAIRE DU CONFLUENT + +Le vocabulaire du Confluent porte l'histoire de la civilisation. Chaque mot est un artefact multi-gĂ©nĂ©rationnel, transparent dans son Ă©tymologie, rĂ©vĂ©lant les valeurs et l'expĂ©rience du peuple Siliaska. + +--- + +## Philosophie lexicale + +Le lexique du Confluent repose sur trois principes : + +1. **Transparence Ă©tymologique** : L'origine des mots reste visible +2. **Accumulation sĂ©mantique** : Les mots composĂ©s portent le sens de leurs parties +3. **Évolution organique** : Le vocabulaire grandit avec la civilisation + +--- + +## Statistiques du lexique + +### Vue d'ensemble (Ancien Confluent v2.1) + +| CatĂ©gorie | Nombre | Ratio | +|-----------|--------|-------| +| **Racines totales** | 176 | 100% | +| Racines sacrĂ©es (V-) | 19 | 11% | +| Racines standards (C-) | 157 | 89% | +| **Verbes** | 36 | - | +| **Pronoms** | 3 | - | +| **Liaisons sacrĂ©es** | 16 | - | +| **Particules** | 23 | - | +| **Conjugateurs** | 14 | - | + +**Objectif** : Atteindre ~20-25% de racines sacrĂ©es pour maintenir l'Ă©quilibre conceptuel. + +--- + +## Le peuple Siliaska + +### Nom du peuple + +**siliaska** [si-li-as-ka] + +**Composition** : sil-i-aska +- **sili** (regard, vision, Ɠil) +- **-i-** (liaison agent actif : "celui qui porte") +- **aska** (libre, libertĂ©) + +**Sens littĂ©ral** : "Porteurs du regard libre" + +**Sens culturel** : Le peuple de la Civilisation de la Confluence, caractĂ©risĂ© par son regard libre acquis par le pĂšlerinage obligatoire au Gouffre Humide, oĂč ils contemplent les ruines des Premiers AncĂȘtres. + +**Analyse** : +- Type : Nom ethnique (auto-dĂ©signation) +- Structure : standard-liaison-sacrĂ©e (valorisĂ©e) +- Symbolisme : Le "regard libre" est l'accomplissement spirituel central + +--- + +## Les six castes + +### 1. nakukeko - Enfants des Échos + +**Composition** : nak-u-keko +- **naki** (enfant, descendant) +- **-u-** (liaison appartenance : "de, appartenant Ă ") +- **keko** (Ă©cho, rĂ©sonance) + +**Sens littĂ©ral** : "Enfants de l'Ă©cho" + +**RĂŽle** : Habitants souterrains des Antres, pĂąles, adaptĂ©s aux grottes, maĂźtres carriers et sculpteurs + +**CaractĂ©ristiques** : +- Vivent dans les Kekutoka (Antres des Échos) +- Extraient l'argile vivante +- CrĂ©ent les glyphes et sculptures +- SensibilitĂ© acoustique dĂ©veloppĂ©e + +--- + +### 2. nakuura - Enfants du Courant + +**Composition** : nak-u-ura +- **naki** (enfant, descendant) +- **-u-** (liaison appartenance : "de") +- **ura** (eau, fluide) + +**Sens littĂ©ral** : "Enfants de l'eau" + +**RĂŽle** : PĂȘcheurs vivant sur pilotis, contrĂŽlent ressources aquatiques + +**CaractĂ©ristiques** : +- Villages sur pilotis au bord des riviĂšres +- MaĂźtres de la pĂȘche et navigation +- ContrĂŽlent ressources aquatiques +- Liens avec le Vukuura (Gouffre Humide) + +--- + +### 3. aliaska - Ailes-Grises + +**Composition** : al-i-aska +- **alu** (grue, Regard-Libre) +- **-i-** (liaison agent actif : "celui qui") +- **aska** (libre, libertĂ©) + +**Sens littĂ©ral** : "Ceux qui portent l'aile libre" + +**RĂŽle** : Chamans dresseurs de Regards-Libres (grues cendrĂ©es), guides des Ăąmes mourantes + +**CaractĂ©ristiques** : +- Dressent et communiquent avec les grues sacrĂ©es +- RĂŽle spirituel et rituel +- Guident les mourants vers les ancĂȘtres +- Portent des plumes grises + +--- + +### 4. akoazana - Faucons Chasseurs + +**Composition** : ak-oa-zana +- **aki** (faucon) +- **-oa-** (liaison rĂ©solution : "surmontĂ©, vainqueur") +- **zana** (chasser, traquer) + +**Sens littĂ©ral** : "Faucon-vainqueur-chasseur" + +**RĂŽle** : Élite militaire, judiciaire et religieuse, basĂ©s dans les Halls des Serments + +**CaractĂ©ristiques** : +- Guerriers d'Ă©lite et juges +- Application des lois sacrĂ©es +- BasĂ©s dans les Talusavu (Halls des Serments) +- Symbole : le faucon victorieux + +--- + +### 5. takitosa - Passes-bien + +**Composition** : tak-i-tosa +- **taka** (porter, transporter) +- **-i-** (liaison agent actif : "celui qui") +- **tosa** (bon, bien) + +**Sens littĂ©ral** : "Porteurs du bien" + +**RĂŽle** : Marchands et mĂ©diateurs, seule caste mixte + +**CaractĂ©ristiques** : +- Facilitent le commerce et les Ă©changes +- MĂ©diation entre castes et rĂ©gions +- Caste mixte (Ciels-clairs et Sans-ciels) +- Maintiennent la cohĂ©sion sociale + +--- + +### 6. oraumi - Voix de l'Aurore + +**Composition** : or-a-umi +- **ora** (aurore, aube) +- **-a-** (liaison avec : "accompagnĂ© de") +- **umi** (esprit, souffle vital) + +**Sens littĂ©ral** : "Aurore avec esprit" + +**RĂŽle** : Chamans gardiens des lois anciennes, Ă©lite spirituelle + +**CaractĂ©ristiques** : +- Double racine sacrĂ©e (statut spirituel Ă©levĂ©) +- Ciels-clairs nĂ©s sous aurore dĂ©gagĂ©e +- Yeux couleur aurore (rouge/orange/violet) +- Meneurs des Ailes-Grises + +--- + +## Les six lieux majeurs + +### 1. uraakota - La Confluence + +**Composition** : ur-aa-kota +- **ura** (eau, fluide) +- **-aa-** (liaison fusion : "mĂȘlĂ© Ă , confluent") +- **kota** (union, ensemble) + +**Sens littĂ©ral** : "Eau-fusion-union" + +**Description** : Centre spirituel et politique, capitale de la civilisation, au confluent des deux riviĂšres (azur et verte) + +**Symbolisme** : La double voyelle "aa" mime le flux d'eau confluente + +--- + +### 2. vukuura - Gouffre Humide + +**Composition** : vuk-u-ura +- **vuku** (profond, gouffre, abĂźme) +- **-u-** (liaison appartenance : "de") +- **ura** (eau) + +**Sens littĂ©ral** : "Gouffre de l'eau" + +**Description** : Antre le plus mature, contient les ruines des Premiers AncĂȘtres, lieu de pĂšlerinage obligatoire + +**Importance** : C'est ici que les Siliaska acquiĂšrent leur "regard libre" + +--- + +### 3. kekutoka - Antres des Échos + +**Composition** : kek-u-toka +- **keko** (Ă©cho, rĂ©sonance) +- **-u-** (liaison appartenance : "de") +- **toka** (terre, sol) + +**Sens littĂ©ral** : "Écho de la terre" + +**Description** : Colonies souterraines des Nakukeko, chambres sculptĂ©es avec propriĂ©tĂ©s acoustiques + +**CaractĂ©ristiques** : RĂ©seau de grottes habitĂ©es, centres d'extraction d'argile + +--- + +### 4. sikuvela - Cercles de Vigile + +**Composition** : sik-u-vela +- **siku** (cercle, anneau) +- **-u-** (liaison appartenance : "de") +- **vela** (veille, vigile, guet) + +**Sens littĂ©ral** : "Cercles de la veille" + +**Description** : Sites de feux sacrĂ©s sur promontoires montagneux, relais de communication et surveillance + +**Fonction** : RĂ©seau de signalisation par feu, postes de garde + +--- + +### 5. talusavu - Halls des Serments + +**Composition** : tal-u-savu +- **talu** (hall, grande salle) +- **-u-** (liaison appartenance : "de") +- **savu** (serment, promesse) + +**Sens littĂ©ral** : "Halls du serment" + +**Description** : Structures proto-gouvernementales fortifiĂ©es (forteresse + conseil + sanctuaire), base des Faucons Chasseurs + +**Fonction** : Justice, gouvernance locale, rituel du Regard PartagĂ© + +--- + +### 6. ekakova - Grande Fresque + +**Composition** : ek-a-kova +- **eka** (tout, entier, totalitĂ©) +- **-a-** (liaison avec : "avec") +- **kova** (peinture, image, fresque) + +**Sens littĂ©ral** : "TotalitĂ©-avec-peinture" + +**Description** : Fresque multi-gĂ©nĂ©rationnelle dans le Vukuura, couches de peinture superposĂ©es montrant l'histoire de la civilisation + +**Symbolisme** : Artefact central, chaque gĂ©nĂ©ration ajoute sa vision + +--- + +## Racines sacrĂ©es (19) + +Les racines sacrĂ©es commencent par une **voyelle** et reprĂ©sentent des concepts fondamentaux. + +| Forme base | Forme liĂ©e | Sens | Domaine | +|------------|------------|------|---------| +| **aska** | ask- | libre, libertĂ© | Concept fondateur | +| **aita** | ait- | ancĂȘtre, ancien | LignĂ©e sacrĂ©e | +| **asa** | as- | sacrĂ©, divin | Spirituel | +| **apo** | ap- | oiseau, vol | Nature sacrĂ©e | +| **alu** | al- | grue (Regard-Libre) | Animal sacrĂ© | +| **aki** | ak- | faucon | Animal sacrĂ© | +| **ura** | ur- | eau, fluide | ÉlĂ©ment primordial | +| **umi** | um- | esprit, souffle vital | Spirituel | +| **iko** | ik- | un, unique, seul | Concept fondateur | +| **ita** | it- | ĂȘtre, exister | Existence | +| **ena** | en- | origine, source, naissance | Dimension | +| **eka** | ek- | tout, entier, totalitĂ© | Dimension | +| **oki** | ok- | Ă©preuve, dĂ©fi, danger | Conflit sacrĂ© | +| **ora** | or- | aurore, aube | Moment sacrĂ© | +| **onu** | on- | son, vibration | Rituel | +| **anu** | an- | Ăąme, conscience profonde | Spirituel | +| **eku** | ek- | Ă©toile | CĂ©leste sacrĂ© | +| **osi** | os- | mort, mourir | Cycle sacrĂ© | +| **apa** | ap- | aile | Nature sacrĂ©e | + +--- + +## Racines standards par domaine + +### ÉlĂ©ments naturels (15) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| zeru | zer- | ciel | +| toka | tok- | terre, sol | +| suki | suk- | feu, flamme | +| vena | ven- | air, vent | +| kari | kar- | pierre, roche | +| nura | nur- | riviĂšre, courant | +| tasa | tas- | montagne | +| viku | vik- | forĂȘt, arbre | +| luna | lun- | lune | +| sora | sor- | soleil, lumiĂšre | +| taku | tak- | sombre, obscur | +| siku | sik- | sec, aride | +| tani | tan- | vallĂ©e | +| seli | sel- | sel, mer | + +### Corps et sens (12) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| sili | sil- | Ɠil, regard, vision | +| kanu | kan- | main | +| voki | vok- | voix, parole | +| tiku | tik- | oreille, Ă©coute | +| muka | muk- | visage | +| kori | kor- | cƓur | +| sanu | san- | corps | +| peki | pek- | pied, base | +| keko | kek- | Ă©cho, rĂ©sonance | +| puli | pul- | poumon, souffle | +| niku | nik- | chair, viande | +| peli | pel- | peau, surface | +| kina | kin- | sang | + +### Actions (27) + +| Forme base | Verbe | Sens | +|------------|-------|------| +| mira | mirak | voir, observer | +| teki | tekis | aller, chemin | +| kita | kitan | donner | +| pasa | pasak | prendre | +| neka | nekan | faire, crĂ©er | +| vosa | vosak | dire, parler | +| seka | sekam | savoir, connaĂźtre | +| moki | mokis | apprendre | +| kisu | kisun | transmettre, enseigner | +| zaki | zakis | garder, protĂ©ger | +| taka | takan | porter, transporter | +| zana | zanak | chasser, traquer | +| kisu | kisuk | couper, trancher | +| soki | sokik | frapper, battre | +| sopi | sopik | sommeil, dormir | +| tenu | tenuk | tenir, garder | +| tiki | tikis | tisser, lier | +| toku | tokuk | toucher, contact | +| lanu | lanuk | lancer, jeter | +| samu | samuk | assembler, unir | +| levi | levik | lever, Ă©lever | +| tiru | tiruk | tirer, extraire | +| venu | venuk | venir, arriver | +| kapi | kapik | capturer, prendre | +| miku | mikuk | mĂ©langer, mixer | +| koti | kotik | rotation, tourner | + +### Êtres et relations (10) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| kota | kot- | union, confluence, ensemble | +| naki | nak- | enfant, descendant | +| tori | tor- | personne, individu | +| vaku | vak- | ami, alliĂ© | +| zoka | zok- | ennemi, Ă©tranger hostile | +| mitu | mit- | famille, clan | +| kasi | kas- | chef, guide | +| besi | bes- | bĂȘte, animal sauvage | +| pesa | pes- | poisson | +| tibu | tib- | tribu, groupe | +| ziku | zik- | serpent | + +### Concepts abstraits (20) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| veri | ver- | vrai, vĂ©ritĂ© | +| tosa | tos- | bon, bien | +| mako | mak- | grand, vaste | +| pisu | pis- | petit, fin | +| nuvi | nuv- | nouveau, jeune | +| kiru | kir- | Ă©changer, troquer | +| vasi | vas- | pont, lien, passage | +| leku | lek- | loi, rĂšgle | +| melu | mel- | doux, tendre | +| mori | mor- | mĂ©moire, souvenir | +| paku | pak- | paix, calme | +| poku | pok- | poison, toxique | +| seni | sen- | vieux, ancien | +| temi | tem- | temps, durĂ©e | +| valu | val- | valeur, mĂ©rite | +| viku | vik- | victoire, vaincre | +| voli | vol- | vouloir, dĂ©sir | +| zaki | zak- | justice, Ă©quitĂ© | +| varu | var- | guerre, combat | +| seku | sek- | secret, cachĂ© | +| nelu | nel- | noble, Ă©levĂ© | + +### Lieux et structures (16) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| vuku | vuk- | profond, gouffre, abĂźme | +| nisa | nis- | humide, mouillĂ© | +| siku | sik- | cercle, anneau | +| vela | vel- | veille, vigile, guet | +| savu | sav- | serment, promesse | +| talu | tal- | hall, grande salle | +| kova | kov- | peinture, image, fresque | +| koni | kon- | assemblĂ©e, rĂ©union | +| loku | lok- | lieu, endroit | +| kovi | kov- | route, chemin | +| tumi | tum- | tombe, enterrer | +| kama | kam- | chambre, piĂšce | +| sumu | sum- | sommet, haut | +| bori | bor- | bord, limite | +| pori | por- | porte, passage | +| zoni | zon- | zone, rĂ©gion | + +### MatĂ©riaux et objets (15) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| buki | buk- | bois, arbre (matĂ©riau) | +| kelu | kel- | couleur, teinte | +| kesa | kes- | cendre, gris | +| koru | kor- | cercle, cycle | +| lapu | lap- | lait, liquide blanc | +| lina | lin- | ligne, corde | +| vanu | van- | navire, embarcation | +| piki | pik- | pic, pointe | +| pasu | pas- | rouge | +| saki | sak- | sac, contenant | +| sinu | sin- | signe, marque | +| tabi | tab- | tablette, plaque | +| toku | tok- | document, Ă©crit | +| ketu | ket- | chaĂźne, lien | +| metu | met- | mĂ©tal, minerai | + +### Communication (6) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| vesi | ves- | message, nouvelle | +| nomi | nom- | nom, appellation | +| leki | lek- | rĂ©cit, histoire | +| paru | par- | parler, discuter | +| zumi | zum- | rumeur, bruit | +| voki | vok- | appeler, invoquer | + +### Travail et technique (5) + +| Forme base | Forme liĂ©e | Sens | +|------------|------------|------| +| moki | mok- | moule, forme | +| seru | ser- | servir, aider | +| teku | tek- | technique, art | +| tavu | tav- | travail, oeuvre | +| visu | vis- | fixer, attacher | + +--- + +## Verbes spirituels importants + +| Verbe | Racine | Sens | Contexte | +|-------|--------|------|----------| +| **umiak** | umi | mĂ©diter | Pratique spirituelle quotidienne | +| **asavik** | asa | prier | Invocation aux ancĂȘtres | +| **vokis** | voki | invoquer | Appel aux esprits | +| **tosan** | tosa | bĂ©nir | Rituel de bĂ©nĂ©diction | +| **kotam** | kota | communier | Union spirituelle | +| **osian** | osi | mourir | Passage vers les ancĂȘtres | +| **sinan** | sinu | graver | Écriture sur tablettes | +| **kovak** | kova | sculpter | Art sacrĂ© | +| **kelum** | kelu | peindre | Fresque rituelle | +| **samuk** | samu | assembler | Construction communautaire | +| **lokun** | loku | construire | Édification de structures | +| **vukis** | vuku | creuser | CrĂ©ation d'Antres | +| **pesak** | pesa | pĂȘcher | Subsistance des Nakuura | +| **tikun** | tiku | Ă©couter | Écoute rituelle | +| **novak** | nuvi | dĂ©couvrir | Exploration du savoir | +| **morik** | mori | mĂ©moriser | Transmission orale | +| **paruk** | paru | dĂ©battre | Discussion au conseil | +| **velak** | vela | surveiller | Vigile sacrĂ©e | +| **varum** | varu | armer | PrĂ©paration militaire | +| **kapik** | kapi | capturer | Justice par Ă©preuve | +| **kirum** | kiru | troquer | Échange commercial | +| **tenuk** | tenu | entreposer | Conservation ressources | +| **zakin** | zaki | arbitrer | MĂ©diation judiciaire | + +--- + +## DĂ©monstratifs et pronoms + +### Pronoms personnels (3) + +| Pronom | Sens | Personne | +|--------|------|----------| +| **miki** | je, moi | 1sg | +| **sinu** | tu, toi | 2sg | +| **tani** | il, elle, iel | 3sg | + +**Pluriel** : ajouter **su** aprĂšs le pronom +- miki su = nous +- sinu su = vous +- tani su = ils/elles/iels + +### DĂ©monstratifs (2) + +| Racine | Sens | Distance | +|--------|------|----------| +| **tisa** | ici, proche, prĂ©sent | ProximitĂ© | +| **tova** | lĂ -bas, loin, distant | Éloignement | + +**Compositions** : +- tis-i-loku = cet endroit-ci +- tov-i-loku = cet endroit-lĂ  + +--- + +## Nombres (Base 12) + +### Chiffres de base (0-12) + +| Base 10 | Confluent | Forme liĂ©e | +|---------|-----------|------------| +| 0 | zaro | zar- | +| 1 | iko | ik- | +| 2 | diku | dik- | +| 3 | tiru | tir- | +| 4 | katu | kat- | +| 5 | penu | pen- | +| 6 | seku | sek- | +| 7 | sivu | siv- | +| 8 | oktu | okt- | +| 9 | novu | nov- | +| 10 | deku | dek- | +| 11 | levu | lev- | +| 12 | tolu | tol- | + +### Puissances de 12 + +| Valeur | Confluent | Composition | +|--------|-----------|-------------| +| 12 | tolu | douzaine | +| 144 | tolusa | tol-u-sa (grosse) | +| 1728 | toluaa | tol-aa-tol | +| 20736 | tolumako | tol-u-mako | + +--- + +## Exemples de compositions nouvelles + +Le systĂšme morphologique permet de crĂ©er de nouveaux mots par composition. + +### CrĂ©ations validĂ©es rĂ©centes + +| Composition | DĂ©composition | Sens | +|-------------|---------------|------| +| **silieveri** | sil-ie-veri | Clairvoyant (regard qui reçoit vĂ©ritĂ©) | +| **koriooki** | kor-o-oki | Angoisse (cƓur contre danger) | +| **koriakota** | kor-a-kota | Amour (cƓur avec union) | +| **umiiaska** | um-ii-aska | Esprit libre (esprit qui EST libre) | +| **nakiuseni** | nak-iu-seni | Enfant devenant ancien (vieillissement) | + +### ModĂšles de crĂ©ation + +**Agent d'action** : racine-verbe + -i- + racine-concept +``` +zana (chasser) + -i- + besi (bĂȘte) +→ zanibesi = chasseur de bĂȘtes +``` + +**Lieu d'activitĂ©** : racine-activitĂ© + -u- + racine-lieu +``` +seka (savoir) + -u- + talu (hall) +→ sekutalu = hall du savoir, bibliothĂšque +``` + +**État Ă©motionnel** : kori (cƓur) + liaison + racine-source +``` +kori + -a- + sora (soleil) +→ koriasora = joie (cƓur avec soleil) +``` + +--- + +## Vocabulaire rituel et formulaire + +### Formules de salutation + +| Formule | Sens | Contexte | +|---------|------|----------| +| **va sili aska** | Que le regard (soit) libre | Salutation traditionnelle | +| **va kota tosa** | Que l'union (soit) bonne | Souhait de confluence | +| **va ora ni sinu** | Que l'aurore (soit) pour toi | BĂ©nĂ©diction matinale | + +### Formules funĂ©raires + +| Formule | Sens | Contexte | +|---------|------|----------| +| **va sili ve sinu vi aita su tekis** | Que ton regard aille vers les ancĂȘtres | Mort honorable | +| **va anu ve sinu vi ena tekis** | Que ton Ăąme aille vers l'origine | Retour au primordial | +| **va aita su ni sinu velas** | Que les ancĂȘtres veillent sur toi | Protection dans l'au-delĂ  | + +### Formules rituelles (Vigile Lunaire) + +| Formule | Sens | Contexte | +|---------|------|----------| +| **va luna ni siliaska velas** | Que la lune veille sur les Siliaska | Ouverture Vigile | +| **va seka ve aita su kisunu** | Que le savoir des ancĂȘtres se transmette | Invocation mĂ©moire | +| **va kota vi eka tekis** | Que l'union aille vers la totalitĂ© | ClĂŽture cĂ©rĂ©monielle | + +--- + +## NĂ©ologismes en dĂ©veloppement + +Le vocabulaire du Confluent continue d'Ă©voluer. Voici des concepts non encore officiellement nommĂ©s : + +### Concepts Ă  dĂ©velopper + +| Concept français | Approche proposĂ©e | Composition possible | +|------------------|-------------------|---------------------| +| OcĂ©an | grande-eau | mako + -aa- + ura → makaura | +| Horizon | limite-ciel | bori + -u- + zeru → boriuzeru | +| Étranger (neutre) | personne-autre | tori + -e- + loku → torieloku | +| Exil | chemin-loin | teki + -ea- + tova → tekieatova | +| MĂ©moire collective | mĂ©moire-union | mori + -aa- + kota → moriaakota | +| Innovation | nouveau-faire | nuvi + -i- + neka → nuviuneka | +| Trahison | faux-serment | veri + -o- + savu → veriosavu | + +--- + +## Index alphabĂ©tique des racines + +### A +aita (ancĂȘtre), aki (faucon), alu (grue), anu (Ăąme), apa (aile), apo (oiseau), asa (sacrĂ©), aska (libre) + +### B +besi (bĂȘte), bori (bord), buki (bois) + +### E +eka (tout), eku (Ă©toile), ena (origine) + +### I +iko (un), ita (ĂȘtre) + +### K +kama (chambre), kanu (main), kapi (capturer), kari (pierre), kasi (chef), katu (quatre), keko (Ă©cho), kelu (couleur), kesa (cendre), ketu (chaĂźne), kina (sang), kiru (Ă©changer), kisu (transmettre), kita (donner), koni (assemblĂ©e), kori (cƓur), koru (cycle), kota (union), koti (tourner), kova (fresque), kovi (route) + +### L +lapu (lait), lanu (lancer), leki (rĂ©cit), leku (loi), levi (lever), levu (onze), lina (ligne), loku (lieu), luna (lune) + +### M +mako (grand), melu (doux), metu (mĂ©tal), miki (je), miku (mĂ©langer), mira (voir), mitu (famille), moki (apprendre), mori (mĂ©moire), muka (visage) + +### N +naki (enfant), neka (faire), nelu (noble), niku (chair), nisa (humide), nomi (nom), novu (neuf), nura (riviĂšre), nuvi (nouveau) + +### O +oki (Ă©preuve), oktu (huit), onu (son), ora (aurore), osi (mort) + +### P +paku (paix), paru (parler), pasa (prendre), pasu (rouge), peki (pied), peli (peau), penu (cinq), pesa (poisson), piki (pic), pisu (petit), poku (poison), pori (porte), puli (poumon) + +### S +saki (sac/garder), samu (assembler), sanu (corps), savu (serment), seka (savoir), seku (six/secret), seli (sel), seni (vieux), seru (servir), siku (cercle/sec), sili (regard), sinu (tu/signe), sivu (sept), soki (frapper/feu), sopi (dormir), sora (soleil), sumu (sommet) + +### T +tabi (tablette), taka (porter), taku (sombre), talu (hall), tani (vallĂ©e/il-elle), tasa (montagne), tavu (travail), teki (aller), teku (technique), temi (temps), tenu (tenir), tibu (tribu), tiki (tisser), tiku (oreille), tiru (trois/tirer), tisa (ici), toka (terre), toku (toucher/document), tolu (douze), tori (personne), tosa (bon), tova (lĂ -bas), tumi (tombe) + +### U +umi (esprit), ura (eau) + +### V +vaku (ami), valu (valeur), vanu (navire), varu (guerre), vasi (pont), vela (vigile), vena (air), venu (venir), veri (vrai), vesi (message), viku (forĂȘt/victoire), visu (fixer), voki (voix/invoquer), voli (vouloir), vosa (dire), vuku (gouffre) + +### Z +zaki (garder/justice), zana (chasser), zaro (zĂ©ro), zeru (ciel), zika (serpent), zoka (ennemi), zoni (zone), zumi (rumeur) + +--- + +## Annexe : FrĂ©quence d'usage + +### 20 racines les plus frĂ©quentes dans compositions + +1. **sili** (regard) - 12 compositions validĂ©es +2. **naki** (enfant) - 8 compositions +3. **ura** (eau) - 7 compositions +4. **kori** (cƓur) - 6 compositions +5. **kota** (union) - 5 compositions +6. **aita** (ancĂȘtre) - 4 compositions +7. **aska** (libre) - 4 compositions +8. **toka** (terre) - 3 compositions +9. **seka** (savoir) - 3 compositions +10. **vela** (vigile) - 2 compositions + +### Liaisons les plus utilisĂ©es + +1. **-u-** (appartenance) : 40% des compositions +2. **-i-** (agent) : 25% +3. **-a-** (avec) : 15% +4. **-aa-** (fusion) : 10% +5. Autres : 10% + +--- + +*Document linguistique - Civilisation de la Confluence* +*Lexique complet disponible dans : data/lexique.json*