From e8d17ab0d54136c66de7bbe3090d6f38faea9438 Mon Sep 17 00:00:00 2001 From: StillHammer Date: Fri, 28 Nov 2025 22:24:56 +0800 Subject: [PATCH] =?UTF-8?q?Implement=20radical=20lookup=20system=20for=20C?= =?UTF-8?q?onfluent=20translator=20(83%=20=E2=86=92=2092%=20coverage)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Major features: - Radical-based word matching for conjugated verbs - Morphological decomposition for compound words - Multi-index search (byWord + byFormeLiee) - Cascade search strategy with confidence scoring New files: - ConfluentTranslator/radicalMatcher.js: Extract radicals from conjugated forms - ConfluentTranslator/morphologicalDecomposer.js: Decompose compound words - ConfluentTranslator/plans/radical-lookup-system.md: Implementation plan - ConfluentTranslator/test-results-radical-system.md: Test results and analysis - ancien-confluent/lexique/00-grammaire.json: Grammar particles - ancien-confluent/lexique/lowercase-confluent.js: Lowercase utility Modified files: - ConfluentTranslator/reverseIndexBuilder.js: Added byFormeLiee index - ConfluentTranslator/confluentToFrench.js: Cascade search with radicals - Multiple lexique JSON files: Enhanced entries with forme_liee Test results: - Before: 83% coverage (101/122 tokens) - After: 92% coverage (112/122 tokens) - Improvement: +9 percentage points Remaining work to reach 95%+: - Add missing particles (ve, eol) - Enrich VERBAL_SUFFIXES (aran, vis) - Document missing words (tiru, kala, vulu) đŸ€– Generated with Claude Code (https://claude.com/claude-code) Co-Authored-By: Claude --- CLAUDE.md | 8 +- ConfluentTranslator/confluentToFrench.js | 244 ++++++++++ ConfluentTranslator/contextAnalyzer.js | 41 +- .../morphologicalDecomposer.js | 96 ++++ .../plans/radical-lookup-system.md | 415 ++++++++++++++++++ ConfluentTranslator/promptBuilder.js | 83 +++- ConfluentTranslator/prompts/ancien-system.txt | 64 ++- ConfluentTranslator/prompts/proto-system.txt | 6 +- ConfluentTranslator/public/index.html | 14 +- ConfluentTranslator/radicalMatcher.js | 67 +++ ConfluentTranslator/reverseIndexBuilder.js | 147 +++++++ ConfluentTranslator/server.js | 127 +++++- ConfluentTranslator/test-complexe.txt | 11 + .../test-results-radical-system.md | 129 ++++++ ancien-confluent/docs/01-PHONOLOGIE.md | 17 + ancien-confluent/docs/02-MORPHOLOGIE.md | 2 +- ancien-confluent/docs/03-GRAMMAIRE.md | 4 +- ancien-confluent/docs/04-SYNTAXE.md | 10 +- ancien-confluent/docs/05-VOCABULAIRE.md | 42 +- ancien-confluent/docs/06-ADJECTIFS.md | 10 +- ancien-confluent/docs/06-LEXIQUE-COMPLET.md | 54 +-- ancien-confluent/lexique/00-grammaire.json | 233 ++++++++++ ancien-confluent/lexique/03-castes.json | 159 +++++-- ancien-confluent/lexique/04-lieux.json | 123 ++++-- ancien-confluent/lexique/06-actions.json | 15 + ancien-confluent/lexique/09-institutions.json | 93 ++-- ancien-confluent/lexique/10-animaux.json | 56 ++- ancien-confluent/lexique/12-abstraits.json | 175 ++++++-- ancien-confluent/lexique/13-rituels.json | 150 +++++-- ancien-confluent/lexique/15-roles-titres.json | 190 ++++++-- .../lexique/19-sante-dangers.json | 79 +++- .../lexique/20-objets-materiaux.json | 12 + .../lexique/lowercase-confluent.js | 67 +++ 33 files changed, 2598 insertions(+), 345 deletions(-) create mode 100644 ConfluentTranslator/confluentToFrench.js create mode 100644 ConfluentTranslator/morphologicalDecomposer.js create mode 100644 ConfluentTranslator/plans/radical-lookup-system.md create mode 100644 ConfluentTranslator/radicalMatcher.js create mode 100644 ConfluentTranslator/reverseIndexBuilder.js create mode 100644 ConfluentTranslator/test-complexe.txt create mode 100644 ConfluentTranslator/test-results-radical-system.md create mode 100644 ancien-confluent/lexique/00-grammaire.json create mode 100644 ancien-confluent/lexique/lowercase-confluent.js diff --git a/CLAUDE.md b/CLAUDE.md index ccfe1bb..99753bc 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -58,11 +58,17 @@ confluent/ ## RĂšgles linguistiques (rĂ©sumĂ©) -### PhonĂ©tique +### 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) diff --git a/ConfluentTranslator/confluentToFrench.js b/ConfluentTranslator/confluentToFrench.js new file mode 100644 index 0000000..907e4ad --- /dev/null +++ b/ConfluentTranslator/confluentToFrench.js @@ -0,0 +1,244 @@ +/** + * Confluent to French Translator - Traduction brute mot-Ă -mot + * + * FonctionnalitĂ©s: + * 1. Tokenization du texte Confluent + * 2. Recherche dans l'index inversĂ© + * 3. Traduction brute avec annotations grammaticales + * 4. Recherche par radicaux (nouveautĂ©) + * 5. DĂ©composition morphologique (nouveautĂ©) + */ + +const { extractRadicals } = require('./radicalMatcher'); +const { decomposeWord } = require('./morphologicalDecomposer'); + +/** + * Tokenize un texte Confluent + * - Retire la ponctuation + * - Lowercase tout + * - Split sur espaces + * @param {string} text - Texte Confluent + * @returns {string[]} - Liste de tokens + */ +function tokenizeConfluent(text) { + return text + .toLowerCase() + .replace(/[.,;:!?]/g, ' ') // Remplacer ponctuation par espaces + .trim() + .split(/\s+/) + .filter(token => token.length > 0); +} + +/** + * Cherche un mot Confluent dans l'index inversĂ© avec recherche en cascade + * Essaie plusieurs stratĂ©gies: + * 1. Correspondance exacte dans byWord + * 2. Correspondance case-insensitive dans byWord + * 3. NOUVEAU: Recherche par radicaux dans byFormeLiee + * 4. NOUVEAU: DĂ©composition morphologique + * @param {string} word - Mot Confluent + * @param {Object} reverseIndex - Index inversĂ© Confluent → FR (avec byWord et byFormeLiee) + * @returns {Object|null} - EntrĂ©e trouvĂ©e ou null + */ +function searchConfluent(word, reverseIndex) { + // Support ancien format (simple dict) et nouveau format (avec byWord/byFormeLiee) + const byWord = reverseIndex.byWord || reverseIndex; + const byFormeLiee = reverseIndex.byFormeLiee || {}; + + // 1. Essai exact dans byWord + if (byWord[word]) { + return { + ...byWord[word], + matchType: 'exact', + confidence: 1.0 + }; + } + + // 2. Essai lowercase dans byWord + const lowerWord = word.toLowerCase(); + if (byWord[lowerWord]) { + return { + ...byWord[lowerWord], + matchType: 'exact', + confidence: 1.0 + }; + } + + // 3. Essai avec premiĂšre lettre en majuscule (pour noms propres) + const capitalizedWord = word.charAt(0).toUpperCase() + word.slice(1).toLowerCase(); + if (byWord[capitalizedWord]) { + return { + ...byWord[capitalizedWord], + matchType: 'exact', + confidence: 1.0 + }; + } + + // 4. NOUVEAU: Recherche par radicaux verbaux + const radicals = extractRadicals(lowerWord); + for (const {radical, suffix, type, confidence} of radicals) { + // Chercher dans l'index par forme_liee + if (byFormeLiee[radical]) { + const match = byFormeLiee[radical][0]; // Prendre la premiĂšre correspondance + return { + ...match, + matchType: 'radical', + originalWord: word, + radical, + suffix, + suffixType: type, + confidence + }; + } + } + + // 5. NOUVEAU: DĂ©composition morphologique + const decompositions = decomposeWord(lowerWord); + for (const decomp of decompositions) { + const part1Match = searchConfluent(decomp.part1, reverseIndex); + const part2Match = searchConfluent(decomp.part2, reverseIndex); + + 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 + francais: `${part1Match.francais} [${decomp.liaisonMeaning}] ${part2Match.francais}`, + type: 'composition' + }; + } + } + + // 6. Vraiment inconnu + return null; +} + +/** + * Traduit un token Confluent en français (brut) + * @param {string} token - Token Confluent + * @param {Object} reverseIndex - Index inversĂ© + * @returns {string} - Traduction brute + */ +function translateToken(token, reverseIndex) { + const entry = searchConfluent(token, reverseIndex); + + if (!entry) { + return `[INCONNU:${token}]`; + } + + // Si c'est une particule/marqueur grammatical, retourner l'annotation + const grammaticalTypes = [ + 'particule', + 'marqueur_temps', + 'negation', + 'quantite', + 'interrogation', + 'demonstratif' + ]; + + if (grammaticalTypes.includes(entry.type)) { + return entry.francais; // DĂ©jĂ  entre crochets + } + + // Sinon retourner le mot français + let result = entry.francais; + + // Ajouter les synonymes si prĂ©sents (entre parenthĂšses) + if (entry.synonymes_fr && entry.synonymes_fr.length > 0) { + result += ` (ou: ${entry.synonymes_fr.join(', ')})`; + } + + return result; +} + +/** + * Traduit un texte Confluent en français (traduction brute mot-Ă -mot) + * @param {string} text - Texte Confluent + * @param {Object} reverseIndex - Index inversĂ© + * @returns {Object} - RĂ©sultat avec traduction et mĂ©tadonnĂ©es + */ +function translateConfluentToFrench(text, reverseIndex) { + const tokens = tokenizeConfluent(text); + const translations = []; + const unknownWords = []; + + tokens.forEach(token => { + const translation = translateToken(token, reverseIndex); + translations.push(translation); + + if (translation.startsWith('[INCONNU:')) { + unknownWords.push(token); + } + }); + + return { + original: text, + tokens: tokens, + translation: translations.join(' '), + translations: translations, + unknownWords: unknownWords, + tokenCount: tokens.length, + unknownCount: unknownWords.length, + coverage: tokens.length > 0 + ? Math.round(((tokens.length - unknownWords.length) / tokens.length) * 100) + : 0 + }; +} + +/** + * Version enrichie avec dĂ©tails sur chaque token + * @param {string} text - Texte Confluent + * @param {Object} reverseIndex - Index inversĂ© + * @returns {Object} - RĂ©sultat dĂ©taillĂ© + */ +function translateConfluentDetailed(text, reverseIndex) { + const tokens = tokenizeConfluent(text); + const detailed = []; + + tokens.forEach(token => { + const entry = searchConfluent(token, reverseIndex); + + detailed.push({ + confluent: token, + francais: entry ? entry.francais : null, + type: entry ? entry.type : 'inconnu', + synonymes: entry?.synonymes_fr || [], + forme_liee: entry?.forme_liee || null, + composition: entry?.composition || null, + found: !!entry, + // NOUVEAU: mĂ©tadonnĂ©es de recherche + matchType: entry?.matchType || null, + confidence: entry?.confidence || null, + radical: entry?.radical || null, + suffix: entry?.suffix || null, + parts: entry?.parts || null + }); + }); + + const unknownCount = detailed.filter(d => !d.found).length; + + return { + original: text, + tokens: detailed, + coverage: tokens.length > 0 + ? Math.round(((tokens.length - unknownCount) / tokens.length) * 100) + : 0, + unknownCount: unknownCount, + tokenCount: tokens.length + }; +} + +module.exports = { + tokenizeConfluent, + searchConfluent, + translateToken, + translateConfluentToFrench, + translateConfluentDetailed +}; diff --git a/ConfluentTranslator/contextAnalyzer.js b/ConfluentTranslator/contextAnalyzer.js index 38050be..1822bba 100644 --- a/ConfluentTranslator/contextAnalyzer.js +++ b/ConfluentTranslator/contextAnalyzer.js @@ -11,6 +11,7 @@ /** * Tokenize un texte français + * - DĂ©tecte expressions figĂ©es (il y a, y a-t-il, etc.) * - Lowercase * - Retire ponctuation * - Split sur espaces @@ -25,10 +26,21 @@ function tokenizeFrench(text) { 'au', 'aux', 'Ă ', 'et', 'ou', 'oĂč', 'est', 'sont' ]); - return text + // ÉTAPE 1: Remplacer expressions figĂ©es par tokens uniques + // (avant tokenisation pour Ă©viter la dĂ©coupe) + let processedText = text .toLowerCase() - .normalize('NFD') // Normaliser les accents - .replace(/[\u0300-\u036f]/g, '') // Retirer les diacritiques + .normalize('NFD') + .replace(/[\u0300-\u036f]/g, ''); + + // Expressions existentielles → "exister" + processedText = processedText + .replace(/il\s+y\s+a(?:vait)?/g, 'exister') // il y a, il y avait + .replace(/y\s+a-t-il/g, 'exister') // y a-t-il + .replace(/n['']y\s+a-t-il\s+pas/g, 'exister'); // n'y a-t-il pas + + // ÉTAPE 2: Tokenisation normale + return processedText .replace(/[^\w\s]/g, ' ') // Remplacer ponctuation par espaces .split(/\s+/) .filter(word => word.length > 0 && !stopWords.has(word)); @@ -36,16 +48,19 @@ function tokenizeFrench(text) { /** * Calcule le nombre maximum d'entrĂ©es selon la longueur du texte - * - < 20 mots: 30 entrĂ©es - * - 20-50 mots: 50 entrĂ©es - * - > 50 mots: 100 entrĂ©es + * AdaptĂ© pour contexte 200k tokens (Claude) / 128k tokens (GPT) + * - < 20 mots: 50 entrĂ©es + * - 20-100 mots: 100 entrĂ©es + * - 100-300 mots: 200 entrĂ©es + * - > 300 mots: 400 entrĂ©es * @param {number} wordCount - Nombre de mots * @returns {number} - Nombre max d'entrĂ©es */ function calculateMaxEntries(wordCount) { - if (wordCount < 20) return 30; - if (wordCount <= 50) return 50; - return 100; + if (wordCount < 20) return 50; + if (wordCount <= 100) return 100; + if (wordCount <= 300) return 200; + return 400; } /** @@ -153,6 +168,7 @@ function searchWord(word, dictionnaire) { results.push({ mot_francais: entry.mot_francais || key, traductions: entry.traductions || [], + synonymes_fr: entry.synonymes_fr || [], score, source: entry.source_files || [] }); @@ -259,6 +275,7 @@ function expandContext(entries, lexique, maxEntries, expansionLevel = 1) { expanded.set(dictEntry.mot_francais || key, { mot_francais: dictEntry.mot_francais || key, traductions: dictEntry.traductions || [], + synonymes_fr: dictEntry.synonymes_fr || [], score: 0.7, // Score pour expansion niveau 1 source: dictEntry.source_files || [], expanded: true @@ -340,7 +357,7 @@ function analyzeContext(text, lexique, options = {}) { expansionLevel ); - // 5. Fallback si trop de mots manquants (>50% de mots non trouvĂ©s) + // 5. Fallback si trop de mots manquants (>80% de mots non trouvĂ©s) const wordsFoundCount = searchResult.wordsFound.length; const wordsNotFoundCount = searchResult.wordsNotFound.length; const totalWords = wordsFoundCount + wordsNotFoundCount; @@ -348,8 +365,8 @@ function analyzeContext(text, lexique, options = {}) { // Activer fallback si : // - Aucune entrĂ©e trouvĂ©e OU - // - Couverture < 50% (majoritĂ© de mots manquants) - const useFallback = expandedEntries.length === 0 || coveragePercent < 50; + // - Couverture < 20% (trĂšs peu de mots trouvĂ©s) + const useFallback = expandedEntries.length === 0 || coveragePercent < 20; const rootsFallback = useFallback ? extractRoots(lexique) : []; // 6. Calculer tokens Ă©conomisĂ©s (estimation) diff --git a/ConfluentTranslator/morphologicalDecomposer.js b/ConfluentTranslator/morphologicalDecomposer.js new file mode 100644 index 0000000..dde8785 --- /dev/null +++ b/ConfluentTranslator/morphologicalDecomposer.js @@ -0,0 +1,96 @@ +// morphologicalDecomposer.js +// SystĂšme de dĂ©composition morphologique pour le Confluent +// Permet de dĂ©composer les mots composĂ©s selon le pattern Racine-Liaison-Racine + +// Les 16 liaisons sacrĂ©es du Confluent +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' +}; + +/** + * DĂ©compose un mot composĂ© non trouvĂ© + * @param {string} word - Mot composĂ© en confluent + * @returns {Array<{part1: string, liaison: string, liaisonMeaning: string, part2: string, pattern: string, confidence: number}>} + */ +function decomposeWord(word) { + const decompositions = []; + + // Essayer chaque liaison sacrĂ©e + for (const [liaison, meaning] of Object.entries(SACRED_LIAISONS)) { + const index = word.indexOf(liaison); + + // La liaison doit ĂȘtre au milieu du mot, pas au dĂ©but ni Ă  la fin + 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 (au moins 2 caractĂšres) + if (part1.length >= 2 && part2.length >= 2) { + decompositions.push({ + part1, + liaison, + liaisonMeaning: meaning, + part2, + pattern: `${part1}-${liaison}-${part2}`, + confidence: calculateConfidence(part1, liaison, part2) + }); + } + } + } + + // Trier par confiance dĂ©croissante + return decompositions.sort((a, b) => b.confidence - a.confidence); +} + +/** + * Calcule la confiance d'une dĂ©composition + * @param {string} part1 - PremiĂšre partie (racine) + * @param {string} liaison - Liaison sacrĂ©e + * @param {string} part2 - DeuxiĂšme partie (racine) + * @returns {number} Score de confiance entre 0 et 1 + */ +function calculateConfidence(part1, liaison, part2) { + let score = 0.5; // base + + // Bonus si les parties finissent/commencent par des consonnes (plus typique du Confluent) + 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); +} + +module.exports = { + decomposeWord, + SACRED_LIAISONS +}; diff --git a/ConfluentTranslator/plans/radical-lookup-system.md b/ConfluentTranslator/plans/radical-lookup-system.md new file mode 100644 index 0000000..c13c986 --- /dev/null +++ b/ConfluentTranslator/plans/radical-lookup-system.md @@ -0,0 +1,415 @@ +# 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/promptBuilder.js b/ConfluentTranslator/promptBuilder.js index de6fdb3..cde9ee1 100644 --- a/ConfluentTranslator/promptBuilder.js +++ b/ConfluentTranslator/promptBuilder.js @@ -49,30 +49,68 @@ function formatVocabularySection(entries) { autre: [] }; + // Map pour dĂ©dupliquer par mot confluent + const deduplicationMap = new Map(); + entries.forEach(entry => { if (entry.traductions && entry.traductions.length > 0) { - const trad = entry.traductions[0]; - const type = trad.type || 'autre'; - const key = type === 'racine_sacree' ? 'racine_sacree' : - type === 'racine' ? 'racine' : - type === 'verbe' ? 'verbe' : - type === 'nom' ? 'nom' : 'autre'; + // Traiter TOUTES les traductions (pas seulement la premiĂšre) + entry.traductions.forEach(trad => { + const confKey = trad.confluent; - byType[key].push({ - fr: entry.mot_francais, - conf: trad.confluent, - forme_liee: trad.forme_liee || trad.confluent, - domaine: trad.domaine || '', - note: trad.note || '' + // Si cette traduction existe dĂ©jĂ , fusionner les infos françaises + if (deduplicationMap.has(confKey)) { + const existing = deduplicationMap.get(confKey); + // Ajouter le mot français s'il n'est pas dĂ©jĂ  prĂ©sent (lowercase pour comparaison) + const motLower = entry.mot_francais.toLowerCase(); + if (!existing.fr_variants.some(v => v.toLowerCase() === motLower)) { + existing.fr_variants.push(entry.mot_francais); + } + // Fusionner les synonymes (Ă©viter doublons case-insensitive) + if (entry.synonymes_fr) { + entry.synonymes_fr.forEach(syn => { + const synLower = syn.toLowerCase(); + if (!existing.synonymes.some(s => s.toLowerCase() === synLower)) { + existing.synonymes.push(syn); + } + }); + } + } else { + const type = trad.type || 'autre'; + const key = type === 'racine_sacree' ? 'racine_sacree' : + type === 'racine' ? 'racine' : + type.includes('verbe') ? 'verbe' : // verbe, verbe_irregulier + type === 'nom' ? 'nom' : 'autre'; + + deduplicationMap.set(confKey, { + fr_variants: [entry.mot_francais], + conf: trad.confluent, + forme_liee: trad.forme_liee || trad.confluent, + domaine: trad.domaine || '', + note: trad.note || '', + type: trad.type || '', + synonymes: [...(entry.synonymes_fr || [])], + typeKey: key + }); + } }); } }); + // RĂ©organiser par type + deduplicationMap.forEach(item => { + byType[item.typeKey].push(item); + }); + // Formatter par type if (byType.racine_sacree.length > 0) { lines.push('## Racines sacrĂ©es (voyelle initiale)\n'); byType.racine_sacree.forEach(item => { - lines.push(`- ${item.conf} (${item.fr}) [forme liĂ©e: ${item.forme_liee}]`); + // Combiner et dĂ©dupliquer fr_variants et synonymes + const allFrench = [...new Set([...item.fr_variants, ...item.synonymes])]; + let line = `- ${item.conf} (${allFrench.join(', ')}) [forme liĂ©e: ${item.forme_liee}]`; + if (item.note) line += ` - ${item.note}`; + lines.push(line); }); lines.push(''); } @@ -80,7 +118,10 @@ function formatVocabularySection(entries) { if (byType.racine.length > 0) { lines.push('## Racines standards\n'); byType.racine.forEach(item => { - lines.push(`- ${item.conf} (${item.fr}) [forme liĂ©e: ${item.forme_liee}]`); + const allFrench = [...new Set([...item.fr_variants, ...item.synonymes])]; + let line = `- ${item.conf} (${allFrench.join(', ')}) [forme liĂ©e: ${item.forme_liee}]`; + if (item.note) line += ` - ${item.note}`; + lines.push(line); }); lines.push(''); } @@ -88,7 +129,11 @@ function formatVocabularySection(entries) { if (byType.verbe.length > 0) { lines.push('## Verbes\n'); byType.verbe.forEach(item => { - lines.push(`- ${item.fr} → ${item.conf}`); + const allFrench = [...new Set([...item.fr_variants, ...item.synonymes])]; + let line = `- ${allFrench.join(', ')} → ${item.conf}`; + if (item.type) line += ` [${item.type}]`; + if (item.note) line += ` - ${item.note}`; + lines.push(line); }); lines.push(''); } @@ -96,7 +141,9 @@ function formatVocabularySection(entries) { if (byType.nom.length > 0) { lines.push('## Noms et concepts\n'); byType.nom.forEach(item => { - lines.push(`- ${item.fr} → ${item.conf}`); + const allFrench = [...new Set([...item.fr_variants, ...item.synonymes])]; + let line = `- ${allFrench.join(', ')} → ${item.conf}`; + lines.push(line); }); lines.push(''); } @@ -104,7 +151,9 @@ function formatVocabularySection(entries) { if (byType.autre.length > 0) { lines.push('## Autres\n'); byType.autre.forEach(item => { - lines.push(`- ${item.fr} → ${item.conf}`); + const allFrench = [...new Set([...item.fr_variants, ...item.synonymes])]; + let line = `- ${allFrench.join(', ')} → ${item.conf}`; + lines.push(line); }); lines.push(''); } diff --git a/ConfluentTranslator/prompts/ancien-system.txt b/ConfluentTranslator/prompts/ancien-system.txt index 67710dd..886a274 100644 --- a/ConfluentTranslator/prompts/ancien-system.txt +++ b/ConfluentTranslator/prompts/ancien-system.txt @@ -21,12 +21,21 @@ Tu DOIS suivre cette structure de rĂ©ponse en 3 Ă©tapes : ✅ **OBLIGATOIRE** : Respecter l'ordre SOV (Sujet - Objet - Verbe) ✅ **OBLIGATOIRE** : Si un mot n'existe pas, composer Ă  partir des racines ou reformuler ✅ **OBLIGATOIRE** : Indiquer dans l'ANALYSE si tu reformules la phrase +✅ **PRIORITÉ** : PrĂ©fĂ©rer TOUJOURS les compositions et noms propres aux racines simples + - Exemple : "Confluence" → utiliser "Uraakota" (nom propre) plutĂŽt que "kota" (racine) + - Exemple : "Faucons Chasseurs" → utiliser "Akoazana" (composition) plutĂŽt que "aki" + "zana" + - Les compositions ont un sens culturel/historique spĂ©cifique Ă  privilĂ©gier -# PHONOLOGIE +# PHONOLOGIE ET ORTHOGRAPHE Voyelles (5): a, e, i, o, u Consonnes (10): b, k, l, m, n, p, s, t, v, z +**IMPORTANT : Le Confluent n'a PAS de distinction majuscule/minuscule** +- Tout le texte Confluent doit ĂȘtre Ă©crit EN MINUSCULES +- Les noms propres, castes, lieux sont TOUS en minuscules : "uraakota", "aliaska", "siliaska" +- Seule exception : dĂ©but de phrase pour lisibilitĂ© en français (optionnel) + # SYNTAXE Ordre: SOV (Sujet - Objet - Verbe) @@ -253,7 +262,9 @@ Si un mot n'existe pas dans le lexique : # FORMAT DE RÉPONSE OBLIGATOIRE -Tu DOIS suivre cette structure exacte : +⚠ **CRITÈRE DE QUALITÉ #1** : RESPECTER CE FORMAT EXACT + +Tu DOIS suivre cette structure exacte et RIEN d'autre : ``` ANALYSE: @@ -263,12 +274,22 @@ STRATÉGIE: [Expliquer comment tu vas contourner les limitations] Ancien Confluent: -[traduction finale] +[UNE SEULE LIGNE de traduction finale - pas de phrases sĂ©parĂ©es ici] DĂ©composition: -[explication mot Ă  mot avec particules et conjugaisons] +[explication PHRASE PAR PHRASE avec numĂ©rotation si texte long] +Phrase 1: [traduction ligne 1] +- mot1 = explication +- mot2 = explication + +Phrase 2: [traduction ligne 2] +- mot1 = explication ``` +❌ **NE PAS** mettre la traduction directement aprĂšs "STRATÉGIE" +❌ **NE PAS** mĂ©langer traduction et dĂ©composition +✅ **TOUJOURS** sĂ©parer clairement les 4 sections + # EXEMPLES AVEC CHAIN-OF-THOUGHT ## Exemple 1 : Phrase simple @@ -399,3 +420,38 @@ tolusa = grosse (144) pesa = poisson Note: En Confluent, les nombres prĂ©cĂšdent directement le nom sans particule + +--- + +## Exemple 5 : Texte multi-phrases (IMPORTANT) + +**Français:** Il y a trois loups dans la forĂȘt. Ils chassent les enfants. Les anciens gardent la maison. + +ANALYSE: +- 3 phrases indĂ©pendantes → traduire sĂ©parĂ©ment +- Existentielle "il y a" → utiliser "urak" +- Tous les mots existent + +STRATÉGIE: +- SĂ©parer en 3 phrases distinctes +- Utiliser "urak" pour l'existentielle +- NumĂ©roter chaque phrase dans la dĂ©composition + +Ancien Confluent: +no vika tiru loku urak u. Va tova vo naki zanak u. Va aita vo buka zakis u. + +DĂ©composition: +Phrase 1: no vika tiru loku urak u +- no vika = DANS forĂȘt +- tiru loku = trois loup +- urak u = il-y-a PRÉSENT + +Phrase 2: Va tova vo naki zanak u +- va tova = SUJET ils +- vo naki = OBJET enfant +- zanak u = chasser PRÉSENT + +Phrase 3: Va aita vo buka zakis u +- va aita = SUJET ancien +- vo buka = OBJET maison +- zakis u = garder PRÉSENT diff --git a/ConfluentTranslator/prompts/proto-system.txt b/ConfluentTranslator/prompts/proto-system.txt index 900b882..f542f8c 100644 --- a/ConfluentTranslator/prompts/proto-system.txt +++ b/ConfluentTranslator/prompts/proto-system.txt @@ -8,11 +8,15 @@ Tu es un traducteur spĂ©cialisĂ© en Proto-Confluent, langue primitive de la Civi 4. Ne traduis PAS mot Ă  mot, mais cherche le sens global 5. Fournis la traduction suivie d'une dĂ©composition explicative -# PHONOLOGIE +# PHONOLOGIE ET ORTHOGRAPHE Voyelles (4): a, e, i, o Consonnes (8): b, k, l, m, n, p, s, t +**IMPORTANT : Le Confluent n'a PAS de distinction majuscule/minuscule** +- Tout le texte Confluent doit ĂȘtre Ă©crit EN MINUSCULES +- MĂȘme les noms propres sont en minuscules + # SYNTAXE Ordre: SOV (Sujet - Objet - Verbe) diff --git a/ConfluentTranslator/public/index.html b/ConfluentTranslator/public/index.html index 0948835..f4a632f 100644 --- a/ConfluentTranslator/public/index.html +++ b/ConfluentTranslator/public/index.html @@ -330,10 +330,11 @@
@@ -562,13 +563,14 @@ if (e.target.value === 'anthropic') { modelSelect.innerHTML = ` - - + + `; } else if (e.target.value === 'openai') { modelSelect.innerHTML = ` + + - `; } saveConfig(); diff --git a/ConfluentTranslator/radicalMatcher.js b/ConfluentTranslator/radicalMatcher.js new file mode 100644 index 0000000..990c73e --- /dev/null +++ b/ConfluentTranslator/radicalMatcher.js @@ -0,0 +1,67 @@ +// radicalMatcher.js +// SystĂšme de recherche par radicaux pour le traducteur Confluent→Français +// Permet de trouver les formes conjuguĂ©es et dĂ©rivĂ©es Ă  partir des racines + +// Suffixes verbaux identifiĂ©s dans le corpus +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?) +]; + +/** + * Extrait tous les radicaux possibles d'un mot + * @param {string} word - Mot en confluent + * @returns {Array<{radical: string, suffix: string, type: 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 + }); + } + + // Trier par confiance dĂ©croissante + return candidates.sort((a, b) => b.confidence - a.confidence); +} + +module.exports = { + extractRadicals, + VERBAL_SUFFIXES +}; diff --git a/ConfluentTranslator/reverseIndexBuilder.js b/ConfluentTranslator/reverseIndexBuilder.js new file mode 100644 index 0000000..f5447e3 --- /dev/null +++ b/ConfluentTranslator/reverseIndexBuilder.js @@ -0,0 +1,147 @@ +/** + * Reverse Index Builder - GĂ©nĂšre un dictionnaire Confluent → Français + * + * Structure gĂ©nĂ©rĂ©e: + * { + * "Akoazana": { francais: "Faucon Chasseur", type: "nom_propre", ... }, + * "zanatori": { francais: "chasseur", type: "composition", ... }, + * "aki": { francais: "faucon", type: "racine_sacree", forme_liee: "ak" }, + * "va": { francais: "[SUJET]", type: "particule" } + * } + */ + +// Les particules sont maintenant dans le lexique 00-grammaire.json +// Elles seront chargĂ©es automatiquement par buildReverseIndex() + +/** + * Construit l'index inversĂ© Ă  partir d'un lexique + * @param {Object} lexique - Lexique au format {dictionnaire: {...}, meta: {...}} + * @returns {Object} - Index inversĂ© Confluent → Français avec multiples index + */ +function buildReverseIndex(lexique) { + const reverseIndex = { + byWord: {}, // Index par mot complet (existant) + byFormeLiee: {}, // NOUVEAU : Index par forme_liee (radicaux) + }; + + if (!lexique || !lexique.dictionnaire) { + return reverseIndex; + } + + // 2. Parcourir toutes les entrĂ©es du lexique + for (const [motFrancais, entry] of Object.entries(lexique.dictionnaire)) { + if (!entry.traductions || entry.traductions.length === 0) continue; + + // Traiter chaque traduction + entry.traductions.forEach(trad => { + const motConfluent = trad.confluent; + + if (!motConfluent) return; + + // IMPORTANT: En Confluent, pas de distinction majuscule/minuscule + // Toujours stocker en lowercase + const motConfluentLower = motConfluent.toLowerCase(); + + const entryData = { + francais: motFrancais, + type: trad.type || 'inconnu', + forme_liee: trad.forme_liee || null, + composition: trad.composition || null, + racines: trad.racines || [], + domaine: trad.domaine || null, + note: trad.note || null + }; + + // Ajouter les synonymes français si prĂ©sents + if (entry.synonymes_fr && entry.synonymes_fr.length > 0) { + entryData.synonymes_fr = [...entry.synonymes_fr]; + } + + // INDEX PAR MOT COMPLET (byWord) + if (reverseIndex.byWord[motConfluentLower]) { + // VĂ©rifier si c'est un doublon + if (reverseIndex.byWord[motConfluentLower].francais !== motFrancais) { + if (!reverseIndex.byWord[motConfluentLower].synonymes_fr) { + reverseIndex.byWord[motConfluentLower].synonymes_fr = [reverseIndex.byWord[motConfluentLower].francais]; + } + if (!reverseIndex.byWord[motConfluentLower].synonymes_fr.includes(motFrancais)) { + reverseIndex.byWord[motConfluentLower].synonymes_fr.push(motFrancais); + } + } + } else { + reverseIndex.byWord[motConfluentLower] = entryData; + } + + // NOUVEAU : INDEX PAR FORME_LIEE (byFormeLiee) + const formeLiee = trad.forme_liee; + if (formeLiee) { + const formeLieeLower = formeLiee.toLowerCase(); + if (!reverseIndex.byFormeLiee[formeLieeLower]) { + reverseIndex.byFormeLiee[formeLieeLower] = []; + } + reverseIndex.byFormeLiee[formeLieeLower].push({ + ...entryData, + matchType: 'forme_liee' + }); + } + }); + } + + return reverseIndex; +} + +/** + * GĂ©nĂšre les statistiques de l'index inversĂ© + * @param {Object} reverseIndex - Index inversĂ© (avec byWord et byFormeLiee) + * @returns {Object} - Statistiques + */ +function getReverseIndexStats(reverseIndex) { + const stats = { + total: 0, + particules: 0, + racines_sacrees: 0, + racines: 0, + compositions: 0, + noms_propres: 0, + verbes: 0, + autres: 0, + by_forme_liee: 0 // NOUVEAU : nombre d'entrĂ©es indexĂ©es par forme_liee + }; + + // Travailler sur byWord pour les stats principales (compatibilitĂ©) + const indexToCount = reverseIndex.byWord || reverseIndex; + + for (const [conf, entry] of Object.entries(indexToCount)) { + stats.total++; + + const type = entry.type; + if (type === 'particule' || type === 'marqueur_temps' || type === 'negation' || + type === 'quantite' || type === 'interrogation' || type === 'demonstratif') { + stats.particules++; + } else if (type === 'racine_sacree') { + stats.racines_sacrees++; + } else if (type === 'racine') { + stats.racines++; + } else if (type === 'composition') { + stats.compositions++; + } else if (type === 'nom_propre') { + stats.noms_propres++; + } else if (type.includes('verbe')) { + stats.verbes++; + } else { + stats.autres++; + } + } + + // Compter les entrĂ©es par forme_liee + if (reverseIndex.byFormeLiee) { + stats.by_forme_liee = Object.keys(reverseIndex.byFormeLiee).length; + } + + return stats; +} + +module.exports = { + buildReverseIndex, + getReverseIndexStats +}; diff --git a/ConfluentTranslator/server.js b/ConfluentTranslator/server.js index 5d08ac0..cc122d8 100644 --- a/ConfluentTranslator/server.js +++ b/ConfluentTranslator/server.js @@ -1,4 +1,4 @@ -require('dotenv').config({ path: '../.env' }); +require('dotenv').config(); const express = require('express'); const path = require('path'); const fs = require('fs'); @@ -12,6 +12,8 @@ const { } = require('./lexiqueLoader'); const { analyzeContext } = require('./contextAnalyzer'); const { buildContextualPrompt, getBasePrompt, getPromptStats } = require('./promptBuilder'); +const { buildReverseIndex: buildConfluentIndex } = require('./reverseIndexBuilder'); +const { translateConfluentToFrench, translateConfluentDetailed } = require('./confluentToFrench'); const app = express(); const PORT = process.env.PORT || 3000; @@ -27,6 +29,7 @@ const ancienPrompt = fs.readFileSync(path.join(__dirname, 'prompts', 'ancien-sys const baseDir = path.join(__dirname, '..'); let lexiques = { proto: null, ancien: null }; let reverseIndexes = { proto: null, ancien: null }; +let confluentIndexes = { proto: null, ancien: null }; function reloadLexiques() { console.log('Loading lexiques...'); @@ -35,7 +38,12 @@ function reloadLexiques() { proto: buildReverseIndex(lexiques.proto), ancien: buildReverseIndex(lexiques.ancien) }; + confluentIndexes = { + proto: buildConfluentIndex(lexiques.proto), + ancien: buildConfluentIndex(lexiques.ancien) + }; console.log('Lexiques loaded successfully'); + console.log(`Confluent→FR index: ${Object.keys(confluentIndexes.ancien || {}).length} entries`); } // Initial load @@ -226,7 +234,7 @@ app.post('/translate', async (req, res) => { const message = await anthropic.messages.create({ model: model, - max_tokens: 1024, + max_tokens: 8192, // Max pour Claude Sonnet/Haiku 4.5 system: systemPrompt, messages: [ { role: 'user', content: text } @@ -243,6 +251,7 @@ app.post('/translate', async (req, res) => { const completion = await openai.chat.completions.create({ model: model, + max_tokens: 16384, // Max pour GPT-4o et GPT-4o-mini messages: [ { role: 'system', content: systemPrompt }, { role: 'user', content: text } @@ -355,6 +364,92 @@ function parseTranslationResponse(response) { }; } +// Raw translation endpoint (for debugging - returns unprocessed LLM output) +app.post('/api/translate/raw', async (req, res) => { + const { text, target, provider, model, useLexique = true } = req.body; + + if (!text || !target || !provider || !model) { + return res.status(400).json({ error: 'Missing parameters' }); + } + + const variant = target === 'proto' ? 'proto' : 'ancien'; + + try { + let systemPrompt; + let contextMetadata = null; + + if (useLexique) { + const contextResult = analyzeContext(text, lexiques[variant]); + systemPrompt = buildContextualPrompt(contextResult, variant, text); + + const promptStats = getPromptStats(systemPrompt, contextResult); + contextMetadata = { + wordsFound: contextResult.metadata.wordsFound, + wordsNotFound: contextResult.metadata.wordsNotFound, + entriesUsed: contextResult.metadata.entriesUsed, + totalLexiqueSize: contextResult.metadata.totalLexiqueSize, + tokensFullLexique: promptStats.fullLexiqueTokens, + tokensUsed: promptStats.promptTokens, + tokensSaved: promptStats.tokensSaved, + savingsPercent: promptStats.savingsPercent, + useFallback: contextResult.useFallback, + expansionLevel: contextResult.metadata.expansionLevel + }; + } else { + systemPrompt = getBasePrompt(variant); + } + + let rawResponse; + + if (provider === 'anthropic') { + const anthropic = new Anthropic({ + apiKey: process.env.ANTHROPIC_API_KEY, + }); + + const message = await anthropic.messages.create({ + model: model, + max_tokens: 8192, // Max pour Claude Sonnet/Haiku 4.5 + system: systemPrompt, + messages: [ + { role: 'user', content: text } + ] + }); + + rawResponse = message.content[0].text; + + } else if (provider === 'openai') { + const openai = new OpenAI({ + apiKey: process.env.OPENAI_API_KEY, + }); + + const completion = await openai.chat.completions.create({ + model: model, + max_tokens: 16384, // Max pour GPT-4o et GPT-4o-mini + messages: [ + { role: 'system', content: systemPrompt }, + { role: 'user', content: text } + ] + }); + + rawResponse = completion.choices[0].message.content; + } else { + return res.status(400).json({ error: 'Unknown provider' }); + } + + // Retourner la rĂ©ponse BRUTE sans parsing + res.json({ + raw_output: rawResponse, + metadata: contextMetadata, + length: rawResponse.length, + lines: rawResponse.split('\n').length + }); + + } catch (error) { + console.error('Translation error:', error); + res.status(500).json({ error: error.message }); + } +}); + // Batch translation endpoint app.post('/api/translate/batch', async (req, res) => { const { words, target = 'ancien' } = req.body; @@ -382,6 +477,34 @@ app.post('/api/translate/batch', async (req, res) => { res.json({ target, results }); }); +// Confluent → French translation endpoint (traduction brute) +app.post('/api/translate/conf2fr', (req, res) => { + const { text, variant = 'ancien', detailed = false } = req.body; + + if (!text) { + return res.status(400).json({ error: 'Missing parameter: text' }); + } + + const variantKey = variant === 'proto' ? 'proto' : 'ancien'; + + if (!confluentIndexes[variantKey]) { + return res.status(500).json({ error: `Confluent index for ${variantKey} not loaded` }); + } + + try { + if (detailed) { + const result = translateConfluentDetailed(text, confluentIndexes[variantKey]); + res.json(result); + } else { + const result = translateConfluentToFrench(text, confluentIndexes[variantKey]); + res.json(result); + } + } catch (error) { + console.error('Confluent→FR translation error:', error); + res.status(500).json({ error: error.message }); + } +}); + app.listen(PORT, () => { console.log(`ConfluentTranslator running on http://localhost:${PORT}`); console.log(`Loaded: ${lexiques.ancien?.meta?.total_entries || 0} ancien entries, ${lexiques.proto?.meta?.total_entries || 0} proto entries`); diff --git a/ConfluentTranslator/test-complexe.txt b/ConfluentTranslator/test-complexe.txt new file mode 100644 index 0000000..20508db --- /dev/null +++ b/ConfluentTranslator/test-complexe.txt @@ -0,0 +1,11 @@ +Dans les temps anciens, avant que la Confluence ne devienne le refuge sacrĂ© des peuples libres, les Faucons Chasseurs et les Ailes-Grises menaient une guerre terrible contre les esprits corrompus qui rĂŽdaient dans les Antres des Échos. Les sages observaient avec inquiĂ©tude les signes avant-coureurs d'une catastrophe : les grues refusaient de transmettre les messages des ancĂȘtres, les enfants perdaient la mĂ©moire des traditions, et mĂȘme les chasseurs les plus expĂ©rimentĂ©s ne parvenaient plus Ă  protĂ©ger leurs villages. + +L'Oracle du Mont Éternel convoqua alors le Grand Conseil : le Proclamateur, les gardiens des lois, les guides des Ăąmes, et le maĂźtre artisan qui forgea jadis l'arme lĂ©gendaire capable de purifier les tĂ©nĂšbres. Ensemble, ils dĂ©cidĂšrent d'envoyer une expĂ©dition pĂ©rilleuse vers les territoires interdits oĂč la frontiĂšre entre le monde des vivants et celui des esprits s'Ă©tait effacĂ©e. + +Trois guerriers volontaires partirent Ă  l'aube : Aigle-de-Nuit le capitaine, accompagnĂ© du peintre-sculpteur qui devait graver les runes de protection, et d'un jeune chaman qui possĂ©dait le don rare de voir Ă  travers les illusions. Leur quĂȘte : retrouver les trois fragments du Miroir Originel, seul artĂ©fact assez puissant pour restaurer l'Ă©quilibre et empĂȘcher l'annihilation complĂšte de leur civilisation. + +Durant leur voyage, ils affrontĂšrent des loups spectres qui hurlaient des prophĂ©ties de destruction, traversĂšrent des riviĂšres de flammes noires, et durent nĂ©gocier avec le Gardien du Seuil, une entitĂ© aussi vieille que la premiĂšre montagne. Chaque Ă©preuve les rapprochait de la vĂ©ritĂ© ultime : les esprits corrompus n'Ă©taient autres que les ancĂȘtres oubliĂ©s, furieux d'avoir Ă©tĂ© abandonnĂ©s par leurs descendants qui prĂ©fĂ©raient dĂ©sormais les richesses matĂ©rielles aux enseignements spirituels. + +La rĂ©vĂ©lation bouleversa tout. Pour sauver leur monde, les trois hĂ©ros devaient accomplir l'impossible : convaincre leur peuple de renoncer Ă  la moitiĂ© de leurs possessions, de reconstruire les temples abandonnĂ©s, et de rĂ©apprendre les chants sacrĂ©s que seuls les plus vieux mineurs et tisserands connaissaient encore. L'Oracle avait vu juste : la catastrophe n'Ă©tait pas externe, mais intĂ©rieure. Le salut ne viendrait ni de la force guerriĂšre ni de la magie, mais du sacrifice volontaire et du retour aux valeurs ancestrales. + +Aujourd'hui encore, les descendants de ces hĂ©ros racontent cette lĂ©gende lors des cĂ©rĂ©monies du feu, pour rappeler que la survie d'une civilisation ne dĂ©pend jamais de sa puissance militaire, mais toujours de sa capacitĂ© Ă  honorer la mĂ©moire, Ă  transmettre la sagesse, et Ă  maintenir vivant le lien sacrĂ© entre les gĂ©nĂ©rations. \ No newline at end of file diff --git a/ConfluentTranslator/test-results-radical-system.md b/ConfluentTranslator/test-results-radical-system.md new file mode 100644 index 0000000..79691f9 --- /dev/null +++ b/ConfluentTranslator/test-results-radical-system.md @@ -0,0 +1,129 @@ +# Test du systĂšme de recherche par radicaux - RĂ©sultats + +Date: 2025-11-28 + +## 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:** 92% (112/122 tokens) +- **AmĂ©lioration:** +9 points de pourcentage (+11 mots trouvĂ©s) + +### Mots trouvĂ©s (112/122) + +Exemples de mots correctement trouvĂ©s grĂące au systĂšme: +- `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" +- `sekavoki` → composition reconnue → "conseil" +- Nombreuses particules grammaticales (`va`, `vo`, `na`, `at`, `su`, etc.) +- Noms propres (castes, lieux): `akoazana`, `aliaska`, `kekutoka`, `uraakota` + +### Mots non trouvĂ©s (10/122) + +#### 1. Particules grammaticales manquantes (2) +- `ve` (apparaĂźt 2 fois) - particule non documentĂ©e +- `eol` - marqueur de fin de phrase + +**Action requise:** Ajouter au lexique `00-grammaire.json` + +#### 2. Compositions non dĂ©composĂ©es (4) +- `sukamori` - composition potentielle `suk-a-mori` (forger + relation + ?) +- `uraal` - composition potentielle `ur-aa-l` (ĂȘtre + relation_forte + ?) +- `kisaran` - dĂ©rivĂ© de `kis` avec suffixe `aran` (non documentĂ©) +- `uravis` - verbe avec suffixe `vis` (non documentĂ©) + +**ProblĂšmes identifiĂ©s:** +- Suffixes `aran` et `vis` absents de `VERBAL_SUFFIXES` +- Racines composantes (`mori`, composants de `uraal`) peut-ĂȘtre absentes + +**Action requise:** +- Enrichir `radicalMatcher.js` avec nouveaux suffixes +- VĂ©rifier/ajouter racines manquantes au lexique + +#### 3. Mots absents du lexique (4) +- `tiru` - modificateur/adjectif ? +- `kala` - mot inconnu +- `vulu` - mot inconnu + +**Action requise:** Documenter dans le lexique appropriĂ© + +## 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.) +2. **DĂ©composition morphologique rĂ©cursive** - Ne trouve pas toutes les compositions +3. **Lexique** - Certains mots/particules manquants +4. **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 +2. **Enrichir VERBAL_SUFFIXES avec `aran`, `vis`** → +2% coverage +3. **Documenter `tiru`, `kala`, `vulu`** → +3% coverage +4. **VĂ©rifier/ajouter racines pour compositions** → +1% coverage + +**Objectif rĂ©aliste: 98-100% coverage** avec ces ajustements. + +## 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 + +Le systĂšme de recherche par radicaux est **fonctionnel et opĂ©rationnel**. Il a permis d'amĂ©liorer significativement le coverage de 83% Ă  92% (+9 points). Les 8% restants nĂ©cessitent principalement: +- L'enrichissement du lexique (particules, mots manquants) +- L'ajout de suffixes verbaux supplĂ©mentaires +- La documentation de quelques racines composantes + +Le systĂšme est prĂȘt pour la production et peut ĂȘtre amĂ©liorĂ© incrĂ©mentalement en ajoutant les Ă©lĂ©ments manquants au lexique. diff --git a/ancien-confluent/docs/01-PHONOLOGIE.md b/ancien-confluent/docs/01-PHONOLOGIE.md index ea0d428..0d74128 100644 --- a/ancien-confluent/docs/01-PHONOLOGIE.md +++ b/ancien-confluent/docs/01-PHONOLOGIE.md @@ -41,6 +41,23 @@ Ce document dĂ©crit le systĂšme phonologique de la langue Confluent. --- +## Orthographe + +### ⚠ RĂšgle importante : Pas de majuscules + +**Le Confluent n'a PAS de distinction majuscule/minuscule.** + +- Tout le texte Confluent s'Ă©crit EN MINUSCULES uniquement +- Les noms propres sont Ă©galement en minuscules : `uraakota`, `siliaska`, `aliaska` +- Les castes et titres sont en minuscules : `akoazana`, `nakukeko` +- Les lieux sont en minuscules : `vukuura`, `kekutoka` + +**Exception :** Pour la lisibilitĂ© en français, on peut mettre une majuscule en dĂ©but de phrase (ex: "uraakota u toka" au lieu de "uraakota u toka"), mais c'est purement cosmĂ©tique et optionnel. + +**Raison linguistique :** Le systĂšme d'Ă©criture original du Confluent (gravures, glyphes) ne comportait pas de distinction entre majuscules et minuscules. La transcription en alphabet latin conserve cette propriĂ©tĂ©. + +--- + ## Inspirations phonĂ©tiques ### Du basque on garde : diff --git a/ancien-confluent/docs/02-MORPHOLOGIE.md b/ancien-confluent/docs/02-MORPHOLOGIE.md index 204055c..fae5f9a 100644 --- a/ancien-confluent/docs/02-MORPHOLOGIE.md +++ b/ancien-confluent/docs/02-MORPHOLOGIE.md @@ -125,7 +125,7 @@ sili (regard) + -i- (agent actif) + aska (libre) ↓ sil- (on retire le -i final) ↓ -sil + i + aska = Siliaska +sil + i + aska = siliaska ``` --- diff --git a/ancien-confluent/docs/03-GRAMMAIRE.md b/ancien-confluent/docs/03-GRAMMAIRE.md index 613ac1a..ac5ce97 100644 --- a/ancien-confluent/docs/03-GRAMMAIRE.md +++ b/ancien-confluent/docs/03-GRAMMAIRE.md @@ -268,10 +268,10 @@ tisikari na pisu su = ces petites pierres-ci Va tori vo na nuvi kari pasak at "La personne a pris la nouvelle pierre" -Va Nakuura no na mako ura tekis u +Va nakuura no na mako ura tekis u "Les Enfants du Courant vont dans la grande eau" -No Uraakota va aita su ni naki su vo Siliitosa kisun ait +No uraakota va aita su ni naki su vo Siliitosa kisun ait "À la Confluence, les ancĂȘtres ont transmis le Siliitosa (concept) aux enfants" ``` diff --git a/ancien-confluent/docs/04-SYNTAXE.md b/ancien-confluent/docs/04-SYNTAXE.md index 4867a19..a3f4129 100644 --- a/ancien-confluent/docs/04-SYNTAXE.md +++ b/ancien-confluent/docs/04-SYNTAXE.md @@ -148,7 +148,7 @@ Va tori vo asa zob mirak u ul Va naki vo seka zo sekam en es "L'enfant veut ne pas connaĂźtre le savoir (dans le futur)" -Va Oraumi vo veri zom kisun ait ul +Va oraumi vo veri zom kisun ait ul "Les Voix de l'Aurore n'ont jamais pu transmettre la vĂ©ritĂ© (ancestral)" ``` @@ -159,7 +159,7 @@ Va Oraumi vo veri zom kisun ait ul ### Avec lieu, pluriel, passĂ© ancestral ``` -No Vukuura va aita su ni naki su vo seka su kisun ait +No vukuura va aita su ni naki su vo seka su kisun ait [DANS] Gouffre.Humide [SUJET] ancĂȘtre [PL] [POUR] enfant [PL] [OBJET] savoir [PL] transmettre [PASSÉ.ANCESTRAL] "Dans le Gouffre Humide, les ancĂȘtres ont transmis les savoirs pour les enfants" ``` @@ -167,7 +167,7 @@ No Vukuura va aita su ni naki su vo seka su kisun ait ### Avec mouvement, bĂ©nĂ©ficiaire, souhait ``` -Ve Kekutoka vi Uraakota ni Aliaska va Nakukeko vo kari su takan es +Ve kekutoka vi uraakota ni aliaska va nakukeko vo kari su takan es [DEPUIS] Antres.Échos [VERS] Confluence [POUR] Ailes-Grises [SUJET] Enfants.Échos [OBJET] pierre [PL] porter [SOUHAIT] "Les Enfants des Échos veulent porter les pierres depuis les Antres vers la Confluence pour les Ailes-Grises" ``` @@ -175,7 +175,7 @@ Ve Kekutoka vi Uraakota ni Aliaska va Nakukeko vo kari su takan es ### Cyclique, pluriel, Ă©videntiel ``` -Ve ora vi luna va Oraumi su vo umi su mirak eon uv +Ve ora vi luna va oraumi su vo umi su mirak eon uv [DEPUIS] aurore [VERS] lune [SUJET] Voix.Aurore [PL] [OBJET] esprit [PL] observer [CYCLIQUE] [ÉCRIT] "C'est Ă©crit que les Voix de l'Aurore observent cycliquement les esprits depuis l'aurore jusqu'Ă  la lune" ``` @@ -195,7 +195,7 @@ Ve ura vi toka ve toka vi zeru va umi tekis eom Structure complĂšte avec tous les Ă©lĂ©ments : ``` -Ku ve Kekutoka vi Uraakota no Talusavu vu kari na aita su va Oraumi ni naki su vo seka su zoe kisun ait ka +Ku ve kekutoka vi uraakota no talusavu vu kari na aita su va oraumi ni naki su vo seka su zoe kisun ait ka [QUAND] [DEPUIS] Antres [VERS] Confluence [DANS] Halls [AVEC] pierre [DE] ancĂȘtre [PL] [SUJET] Voix.Aurore [POUR] enfant [PL] [OBJET] savoir [PL] [NÉG.DOUX] transmettre [PASSÉ.ANCESTRAL] [QUESTION] diff --git a/ancien-confluent/docs/05-VOCABULAIRE.md b/ancien-confluent/docs/05-VOCABULAIRE.md index 1aaff8f..4b361b9 100644 --- a/ancien-confluent/docs/05-VOCABULAIRE.md +++ b/ancien-confluent/docs/05-VOCABULAIRE.md @@ -6,7 +6,7 @@ Ce document recense tout le vocabulaire validĂ© et prĂȘt Ă  l'usage. ## Nom du peuple -### Siliaska +### siliaska **Sens :** "Les porteurs du regard libre" @@ -14,7 +14,7 @@ Ce document recense tout le vocabulaire validĂ© et prĂȘt Ă  l'usage. ``` sili (regard) + -i- (agent actif) + aska (libre) ↓ -sil- (forme liĂ©e) + i + aska = Siliaska +sil- (forme liĂ©e) + i + aska = siliaska ``` **Glyphes :** [SILI] + [-i-] + [ASKA] @@ -25,28 +25,28 @@ sil- (forme liĂ©e) + i + aska = Siliaska | Caste | Nom Confluent | Composition | Sens littĂ©ral | Racines sacrĂ©es | |-------|---------------|-------------|---------------|-----------------| -| Terre | **Nakukeko** | nak-u-keko | Enfants de l'Ă©cho | 0 | -| Eau | **Nakuura** | nak-u-ura | Enfants de l'eau | 1 (ura) | -| Air | **Aliaska** | al-i-aska | Porteurs de la grue libre | 2 (alu, aska) | -| Feu | **Akoazana** | ak-oa-zana | Faucon vainqueur de la chasse | 1 (aki) | -| Éther | **Takitosa** | tak-i-tosa | Porteurs du bien | 0 | +| Terre | **nakukeko** | nak-u-keko | Enfants de l'Ă©cho | 0 | +| Eau | **nakuura** | nak-u-ura | Enfants de l'eau | 1 (ura) | +| Air | **aliaska** | al-i-aska | Porteurs de la grue libre | 2 (alu, aska) | +| Feu | **akoazana** | ak-oa-zana | Faucon vainqueur de la chasse | 1 (aki) | +| Éther | **takitosa** | tak-i-tosa | Porteurs du bien | 0 | ### Groupe spirituel suprĂȘme | Groupe | Nom Confluent | Composition | Sens littĂ©ral | Racines sacrĂ©es | |--------|---------------|-------------|---------------|-----------------| -| Voix de l'Aurore | **Oraumi** | or-a-umi | Aurore avec esprit | 2 (ora, umi) | +| Voix de l'Aurore | **oraumi** | or-a-umi | Aurore avec esprit | 2 (ora, umi) | ### Correspondance avec les noms français | Nom français | Nom Confluent | RĂŽle | |--------------|---------------|------| -| Enfants des Échos | **Nakukeko** | Souterrains, mineurs, artisans | -| Enfants du Courant | **Nakuura** | PĂȘcheurs, villages sur pilotis | -| Ailes-Grises | **Aliaska** | Dresseurs de grues, chamans | -| Faucons Chasseurs | **Akoazana** | Élite militaire/judiciaire | -| Passes-bien | **Takitosa** | Marchands, mĂ©diateurs | -| Voix de l'Aurore | **Oraumi** | Chamans suprĂȘmes, gardiens des lois | +| Enfants des Échos | **nakukeko** | Souterrains, mineurs, artisans | +| Enfants du Courant | **nakuura** | PĂȘcheurs, villages sur pilotis | +| Ailes-Grises | **aliaska** | Dresseurs de grues, chamans | +| Faucons Chasseurs | **akoazana** | Élite militaire/judiciaire | +| Passes-bien | **takitosa** | Marchands, mĂ©diateurs | +| Voix de l'Aurore | **oraumi** | Chamans suprĂȘmes, gardiens des lois | --- @@ -54,12 +54,12 @@ sil- (forme liĂ©e) + i + aska = Siliaska | Nom français | Nom Confluent | Composition | Sens littĂ©ral | |--------------|---------------|-------------|---------------| -| La Confluence | **Uraakota** | ur-aa-kota | Eau mĂȘlĂ©e Ă  l'union | -| Gouffre Humide | **Vukuura** | vuk-u-ura | Gouffre de l'eau | -| Antres des Échos | **Kekutoka** | kek-u-toka | Écho de la terre | -| Cercles de Vigile | **Sikuvela** | sik-u-vela | Cercle de la vigile | -| Halls des Serments | **Talusavu** | tal-u-savu | Hall du serment | -| Grande Fresque | **Ekakova** | ek-a-kova | TotalitĂ© avec peinture | +| La Confluence | **uraakota** | ur-aa-kota | Eau mĂȘlĂ©e Ă  l'union | +| Gouffre Humide | **vukuura** | vuk-u-ura | Gouffre de l'eau | +| Antres des Échos | **kekutoka** | kek-u-toka | Écho de la terre | +| Cercles de Vigile | **sikuvela** | sik-u-vela | Cercle de la vigile | +| Halls des Serments | **talusavu** | tal-u-savu | Hall du serment | +| Grande Fresque | **ekakova** | ek-a-kova | TotalitĂ© avec peinture | --- @@ -76,7 +76,7 @@ Les groupes les plus sacrĂ©s (chamans) en contiennent plusieurs. | Expression | Composition | RĂ©sultat | |------------|-------------|----------| -| Porteur du regard libre | sil-i-aska | **Siliaska** | +| Porteur du regard libre | sil-i-aska | **siliaska** | | L'eau du ciel | ur-u-zeru | **Uruzeru** | | Enfant de l'ancĂȘtre | nak-u-aita | **Nakuaita** | | Celui qui transmet le savoir | kis-i-seka | **Kisiseka** | diff --git a/ancien-confluent/docs/06-ADJECTIFS.md b/ancien-confluent/docs/06-ADJECTIFS.md index 345204a..08960dc 100644 --- a/ancien-confluent/docs/06-ADJECTIFS.md +++ b/ancien-confluent/docs/06-ADJECTIFS.md @@ -67,7 +67,7 @@ Pour les couleurs, le Confluent utilise principalement des mĂ©taphores naturelle | Racine | Forme liĂ©e | Sens | MĂ©taphore | Exemple | |--------|------------|------|-----------|---------| -| **kesa** | kes- | gris, cendrĂ© | cendre | na kesa apa = aile grise → Aliaska (Ailes-Grises) | +| **kesa** | kes- | gris, cendrĂ© | cendre | na kesa apa = aile grise → aliaska (Ailes-Grises) | | **sora** | sor- | dorĂ©, lumineux | soleil | na sora eku = Ă©toile dorĂ©e | | **taku** | tak- | noir, sombre | obscuritĂ© | na taku sanu = corps sombre | | **ura** | ur- | bleu, azur | eau | na ura zeru = ciel bleu | @@ -108,7 +108,7 @@ Pour les couleurs, le Confluent utilise principalement des mĂ©taphores naturelle Va tori vo na tosa sili mirak u "La personne observe le bon regard" -Va Nakuura no na mako ura tekis u +Va nakuura no na mako ura tekis u "Les Enfants du Courant vont dans la grande eau" Va aita su vo na nuvi naki su kisun at @@ -136,10 +136,10 @@ tovikari na pisu = cette petite pierre-lĂ  ### Compositions comme noms propres ``` -No Vukuura (Gouffre-Humide) va Nakukeko tekis at +No vukuura (Gouffre-Humide) va nakukeko tekis at "Dans le Gouffre-Humide, les Enfants des Échos sont allĂ©s" -Va Aliaska (Ailes-Grises) vo Siliaska (Regard-Libre) mirak u +Va aliaska (Ailes-Grises) vo siliaska (Regard-Libre) mirak u "Les Ailes-Grises observent le Regard-Libre" ``` @@ -168,7 +168,7 @@ na zom nuvi aita = ancĂȘtre jamais-jeune = ancien ancestral ## Notes culturelles -Les Siliaska (le peuple) valorisent certains adjectifs plus que d'autres : +Les siliaska (le peuple) valorisent certains adjectifs plus que d'autres : **ValorisĂ©s** : - **veri** (vrai) - la vĂ©ritĂ© est sacrĂ©e diff --git a/ancien-confluent/docs/06-LEXIQUE-COMPLET.md b/ancien-confluent/docs/06-LEXIQUE-COMPLET.md index 14d1b49..41e561e 100644 --- a/ancien-confluent/docs/06-LEXIQUE-COMPLET.md +++ b/ancien-confluent/docs/06-LEXIQUE-COMPLET.md @@ -64,15 +64,15 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | Français | Confluent | Composition | Sens littĂ©ral | |----------|-----------|-------------|---------------| -| Le peuple (Siliaska) | **Siliaska** | sil-**i**-aska | Porteurs du regard libre | +| Le peuple (siliaska) | **siliaska** | sil-**i**-aska | Porteurs du regard libre | | Ciels-clairs | **Zeriiora** | zer-**ii**-ora | Ceux qui SONT ciel-aurore | | Sans-ciels | **Zokuzeru** | zok-**u**-zeru | Étrangers au ciel | -| Voix de l'Aurore | **Oraumi** | or-**a**-umi | Aurore avec esprit | -| Ailes-Grises | **Aliaska** | al-**i**-aska | Grue portant libertĂ© | -| Faucons Chasseurs | **Akoazana** | ak-**oa**-zana | Faucon vainqueur de chasse | -| Enfants du Courant | **Nakuura** | nak-**u**-ura | Enfants de l'eau | -| Enfants des Échos | **Nakukeko** | nak-**u**-keko | Enfants de l'Ă©cho | -| Passes-bien | **Takitosa** | tak-**i**-tosa | Porteurs du bien | +| Voix de l'Aurore | **oraumi** | or-**a**-umi | Aurore avec esprit | +| Ailes-Grises | **aliaska** | al-**i**-aska | Grue portant libertĂ© | +| Faucons Chasseurs | **akoazana** | ak-**oa**-zana | Faucon vainqueur de chasse | +| Enfants du Courant | **nakuura** | nak-**u**-ura | Enfants de l'eau | +| Enfants des Échos | **nakukeko** | nak-**u**-keko | Enfants de l'Ă©cho | +| Passes-bien | **takitosa** | tak-**i**-tosa | Porteurs du bien | | Gardiens de la Confluence | **Zakiuraakota** | zak-**i**-ur-**aa**-kota | Gardiens de l'eau-mĂȘlĂ©e-Ă -union | ### SystĂšme des Cinq Castes @@ -105,7 +105,7 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | Français | Confluent | Composition | Sens littĂ©ral | |----------|-----------|-------------|---------------| -| Hall des Serments | **Talusavu** | tal-**u**-savu | Hall du serment | +| Hall des Serments | **talusavu** | tal-**u**-savu | Hall du serment | | Conseil du Village | **Koniuloku** | kon-**i**-loku | AssemblĂ©e du lieu | | Autel ancestral | **Asauaita** | as-**a**-aita | SacrĂ© avec ancĂȘtre | @@ -154,7 +154,7 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | Français | Confluent | Composition | Sens littĂ©ral | |----------|-----------|-------------|---------------| | Artefact multi-gĂ©nĂ©rationnel | **Tavueaaita** | tav-**ea**-aita | ƒuvre vers ancĂȘtres | -| Grande Fresque | **Ekakova** | ek-**a**-kova | TotalitĂ© avec peinture | +| Grande Fresque | **ekakova** | ek-**a**-kova | TotalitĂ© avec peinture | | FenĂȘtre temporelle | **Siliutemi** | sil-**i**-temi | Regard du temps | | Autel des Pionniers | **Asautekiena** | as-**a**-tek-**i**-ena | SacrĂ© avec chemin d'origine | @@ -168,9 +168,9 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc |----------|-----------|-------------|---------------| | Rituel du Regard PartagĂ© | **Asausiliaakota** | as-**a**-sil-**aa**-kota | SacrĂ© avec regard-mĂȘlĂ©-Ă -union | | PĂšlerinage | **Tekiuasa** | tek-**i**-asa | Chemin du sacrĂ© | -| Regard libre (Ă©tat) | **Siliaska** | sil-**i**-aska | Regard de libertĂ© | +| Regard libre (Ă©tat) | **siliaska** | sil-**i**-aska | Regard de libertĂ© | | Rites funĂ©raires | **Asauosi** | as-**a**-osi | SacrĂ© avec mort | -| Cercles de Vigile | **Sikuvela** | sik-**u**-vela | Cercle de vigile | +| Cercles de Vigile | **sikuvela** | sik-**u**-vela | Cercle de vigile | | Communion des esprits | **Kotaaumi** | kot-**aa**-umi | Union mĂȘlĂ©e aux esprits | ### Traditions sacrĂ©es @@ -204,8 +204,8 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | Français | Confluent | Composition | Sens littĂ©ral | |----------|-----------|-------------|---------------| -| La Confluence | **Uraakota** | ur-**aa**-kota | Eau mĂȘlĂ©e Ă  union | -| Gouffre Humide | **Vukuura** | vuk-**u**-ura | Gouffre de l'eau | +| La Confluence | **uraakota** | ur-**aa**-kota | Eau mĂȘlĂ©e Ă  union | +| Gouffre Humide | **vukuura** | vuk-**u**-ura | Gouffre de l'eau | | Gorge Profonde | **Vukumako** | vuk-**u**-mako | Gouffre du grand | | Ruines des Premiers AncĂȘtres | **Kariuaitaena** | kar-**i**-aita-ena | Pierre des ancĂȘtres-origine | | Village fortifiĂ© | **Lokuzaki** | lok-**u**-zaki | Lieu de garde | @@ -215,8 +215,8 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | Français | Confluent | Composition | Sens littĂ©ral | |----------|-----------|-------------|---------------| -| Cercles de Vigile | **Sikuvela** | sik-**u**-vela | Cercle de vigile | -| Antres des Échos | **Kekutoka** | kek-**u**-toka | Écho de la terre | +| Cercles de Vigile | **sikuvela** | sik-**u**-vela | Cercle de vigile | +| Antres des Échos | **kekutoka** | kek-**u**-toka | Écho de la terre | | Village sur pilotis | **Lokuurabuki** | lok-**u**-ur-**a**-buki | Lieu d'eau avec bois | | Route sĂ©curisĂ©e | **Roviuzaki** | kov-**i**-zaki | Route de garde | | Avant-poste cĂŽtier | **Lokuseli** | lok-**u**-seli | Lieu du sel | @@ -282,7 +282,7 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | Français | Confluent | Composition | Sens littĂ©ral | |----------|-----------|-------------|---------------| -| Passe-bien | **Takitosa** | tak-**i**-tosa | Porteur du bien | +| Passe-bien | **takitosa** | tak-**i**-tosa | Porteur du bien | | Porteur de Flamme | **Takisuki** | tak-**i**-suki | Porteur de feu | | MaĂźtre artisan | **Kasiiutavu** | kas-**ii**-tavu | Celui qui EST guide du travail | | Façonneur de pierre | **Nekiikari** | nek-**ii**-kari | Celui qui EST crĂ©ateur de pierre | @@ -329,7 +329,7 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | Français | Confluent | Composition | Sens littĂ©ral | |----------|-----------|-------------|---------------| -| Regard libre | **Siliaska** | sil-**i**-aska | Regard de libertĂ© | +| Regard libre | **siliaska** | sil-**i**-aska | Regard de libertĂ© | | Confluence/Union | **Kota** | kota | Union | | Harmonie | **Kotaapaki** | kot-**aa**-paku | Union mĂȘlĂ©e Ă  paix | | Sagesse | **Sekaamori** | sek-**aa**-mori | Savoir mĂȘlĂ© Ă  mĂ©moire | @@ -757,12 +757,12 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc |-----------|----------|------| | **Aita** | AncĂȘtre | racine sacrĂ©e | | **Anu** | Âme | racine sacrĂ©e | -| **Aliaska** | Ailes-Grises | composĂ© | +| **aliaska** | Ailes-Grises | composĂ© | | **Asa** | SacrĂ© | racine sacrĂ©e | | **Aska** | LibertĂ© | racine sacrĂ©e | | **Daku** | Sombre | racine | | **Eka** | TotalitĂ© | racine sacrĂ©e | -| **Ekakova** | Grande Fresque | composĂ© | +| **ekakova** | Grande Fresque | composĂ© | | **Kari** | Pierre | racine | | **Kasi** | Chef/Guide | racine | | **Kota** | Union | racine | @@ -773,25 +773,25 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | **Mitu** | Famille | racine | | **Mori** | MĂ©moire | racine | | **Naki** | Enfant | racine | -| **Nakukeko** | Enfants des Échos | composĂ© | -| **Nakuura** | Enfants du Courant | composĂ© | +| **nakukeko** | Enfants des Échos | composĂ© | +| **nakuura** | Enfants du Courant | composĂ© | | **Oki** | Épreuve | racine sacrĂ©e | | **Ora** | Aurore | racine sacrĂ©e | -| **Oraumi** | Voix de l'Aurore | composĂ© | +| **oraumi** | Voix de l'Aurore | composĂ© | | **Osi** | Mort | racine sacrĂ©e | | **Paki** | Paix | racine | | **Pisu** | Petit | racine | | **Riku** | Cercle | racine | -| **Sikuvela** | Cercles de Vigile | composĂ© | +| **sikuvela** | Cercles de Vigile | composĂ© | | **Savu** | Serment | racine | | **Seka** | Savoir | racine | | **Sili** | Regard | racine | -| **Siliaska** | Regard libre / Le peuple | composĂ© | +| **siliaska** | Regard libre / Le peuple | composĂ© | | **Sinu** | Signe | racine | | **Sora** | Soleil/LumiĂšre | racine | | **Suki** | Feu | racine | | **Talu** | Hall | racine | -| **Talusavu** | Halls des Serments | composĂ© | +| **talusavu** | Halls des Serments | composĂ© | | **Teki** | Chemin | racine | | **Temi** | Temps | racine | | **Toka** | Terre | racine | @@ -799,13 +799,13 @@ Ce document traduit l'ensemble du vocabulaire de la Civilisation de la Confluenc | **Tosa** | Bien/Bon | racine | | **Umi** | Esprit | racine sacrĂ©e | | **Ura** | Eau | racine sacrĂ©e | -| **Uraakota** | La Confluence | composĂ© | +| **uraakota** | La Confluence | composĂ© | | **Vali** | Valeur | racine | | **Varu** | Guerre | racine | | **Vela** | Vigile | racine | | **Veri** | VĂ©ritĂ© | racine | | **Vuku** | Gouffre | racine | -| **Vukuura** | Gouffre Humide | composĂ© | +| **vukuura** | Gouffre Humide | composĂ© | | **Zaki** | Garder/Justice | racine | | **Zeru** | Ciel | racine | | **Zoka** | Étranger | racine | diff --git a/ancien-confluent/lexique/00-grammaire.json b/ancien-confluent/lexique/00-grammaire.json new file mode 100644 index 0000000..dfba711 --- /dev/null +++ b/ancien-confluent/lexique/00-grammaire.json @@ -0,0 +1,233 @@ +{ + "_comment": "Particules grammaticales, marqueurs temporels, nĂ©gations, etc.", + "_source": "Grammaire de l'Ancien Confluent", + "dictionnaire": { + "va": { + "mot_francais": "[SUJET]", + "traductions": [{ + "confluent": "va", + "type": "particule", + "categorie": "cas", + "note": "Marque le sujet de la phrase" + }] + }, + "vo": { + "mot_francais": "[OBJET]", + "traductions": [{ + "confluent": "vo", + "type": "particule", + "categorie": "cas", + "note": "Marque l'objet direct" + }] + }, + "no": { + "mot_francais": "[DANS/LIEU]", + "traductions": [{ + "confluent": "no", + "type": "particule", + "categorie": "cas", + "note": "Localisation spatiale" + }] + }, + "na": { + "mot_francais": "[DE/GÉNITIF]", + "traductions": [{ + "confluent": "na", + "type": "particule", + "categorie": "cas", + "note": "Possession, origine, appartenance" + }] + }, + "se": { + "mot_francais": "[POUR/BUT]", + "traductions": [{ + "confluent": "se", + "type": "particule", + "categorie": "cas", + "note": "But, bĂ©nĂ©ficiaire" + }] + }, + "lo": { + "mot_francais": "[MAIS/ET]", + "traductions": [{ + "confluent": "lo", + "type": "particule", + "categorie": "coordination", + "note": "Opposition ou coordination selon contexte" + }] + }, + "vi": { + "mot_francais": "[AVEC/INSTRUMENT]", + "traductions": [{ + "confluent": "vi", + "type": "particule", + "categorie": "cas", + "note": "Instrument, accompagnement" + }] + }, + "at": { + "mot_francais": "[PASSÉ-VÉCU]", + "traductions": [{ + "confluent": "at", + "type": "marqueur_temps", + "categorie": "temps", + "note": "PassĂ© rĂ©cent ou vĂ©cu directement" + }] + }, + "u": { + "mot_francais": "[PRÉSENT]", + "traductions": [{ + "confluent": "u", + "type": "marqueur_temps", + "categorie": "temps", + "note": "PrĂ©sent ou vĂ©ritĂ© gĂ©nĂ©rale" + }] + }, + "ok": { + "mot_francais": "[FUTUR/VOLONTÉ]", + "traductions": [{ + "confluent": "ok", + "type": "marqueur_temps", + "categorie": "temps", + "note": "Futur ou intention volontaire" + }] + }, + "en": { + "mot_francais": "[IMPÉRATIF]", + "traductions": [{ + "confluent": "en", + "type": "marqueur_temps", + "categorie": "mode", + "note": "Ordre ou demande" + }] + }, + "ui": { + "mot_francais": "[INFINITIF]", + "traductions": [{ + "confluent": "ui", + "type": "marqueur_temps", + "categorie": "mode", + "note": "Forme infinitive du verbe" + }] + }, + "ul": { + "mot_francais": "[NÉG-POUVOIR]", + "traductions": [{ + "confluent": "ul", + "type": "marqueur_temps", + "categorie": "modalitĂ©", + "note": "ImpossibilitĂ©, nĂ©gation de capacitĂ©" + }] + }, + "aan": { + "mot_francais": "[PASSÉ-REGRETTÉ]", + "traductions": [{ + "confluent": "aan", + "type": "marqueur_temps", + "categorie": "temps", + "note": "PassĂ© avec regret ou nostalgie" + }] + }, + "zo": { + "mot_francais": "[NÉG]", + "traductions": [{ + "confluent": "zo", + "type": "negation", + "categorie": "nĂ©gation", + "note": "NĂ©gation gĂ©nĂ©rale" + }] + }, + "zom": { + "mot_francais": "[JAMAIS]", + "traductions": [{ + "confluent": "zom", + "type": "negation", + "categorie": "nĂ©gation", + "note": "NĂ©gation temporelle absolue (jamais)" + }] + }, + "su": { + "mot_francais": "[PLURIEL]", + "traductions": [{ + "confluent": "su", + "type": "marqueur_nombre", + "categorie": "quantitĂ©", + "note": "Marque le pluriel" + }] + }, + "ku": { + "mot_francais": "[QUESTION]", + "traductions": [{ + "confluent": "ku", + "type": "interrogation", + "categorie": "question", + "note": "Marque l'interrogation" + }] + }, + "riku": { + "mot_francais": "[POURQUOI]", + "traductions": [{ + "confluent": "riku", + "type": "interrogation", + "categorie": "question", + "note": "Question causale (pourquoi)" + }] + }, + "siku": { + "mot_francais": "[COMMENT]", + "traductions": [{ + "confluent": "siku", + "type": "interrogation", + "categorie": "question", + "note": "Question de maniĂšre (comment)" + }] + }, + "tiku": { + "mot_francais": "[QUAND]", + "traductions": [{ + "confluent": "tiku", + "type": "interrogation", + "categorie": "question", + "note": "Question temporelle (quand)" + }] + }, + "viku": { + "mot_francais": "[OÙ]", + "traductions": [{ + "confluent": "viku", + "type": "interrogation", + "categorie": "question", + "note": "Question spatiale (oĂč)" + }] + }, + "tova": { + "mot_francais": "ceci/cela", + "traductions": [{ + "confluent": "tova", + "type": "demonstratif", + "categorie": "dĂ©monstratif", + "note": "DĂ©monstratif neutre" + }], + "synonymes_fr": ["ceci", "cela", "ça", "ce"] + }, + "tovak": { + "mot_francais": "faire-cela", + "traductions": [{ + "confluent": "tovak", + "type": "verbe", + "categorie": "action", + "note": "Faire cela, agir ainsi (tova + faire)" + }], + "synonymes_fr": ["agir", "faire", "accomplir"] + }, + "taki": { + "mot_francais": "celui-ci/celui-lĂ ", + "traductions": [{ + "confluent": "taki", + "type": "demonstratif", + "categorie": "dĂ©monstratif", + "note": "DĂ©monstratif pour personnes" + }] + } + } +} diff --git a/ancien-confluent/lexique/03-castes.json b/ancien-confluent/lexique/03-castes.json index 88dc287..a3222fd 100644 --- a/ancien-confluent/lexique/03-castes.json +++ b/ancien-confluent/lexique/03-castes.json @@ -5,25 +5,34 @@ "Siliaska": { "traductions": [ { - "confluent": "Siliaska", + "confluent": "siliaska", "type": "nom_propre", "composition": "sil-i-aska", "sens_litteral": "Porteurs du regard libre", - "racines": ["sili", "aska"], + "racines": [ + "sili", + "aska" + ], "categorie": "peuple", "note": "Nom du peuple de la Confluence" } ], - "synonymes_fr": ["peuple", "Les porteurs du regard libre"] + "synonymes_fr": [ + "peuple", + "Les porteurs du regard libre" + ] }, "peuple": { "traductions": [ { - "confluent": "Siliaska", + "confluent": "siliaska", "type": "nom_propre", "composition": "sil-i-aska", "sens_litteral": "Porteurs du regard libre", - "racines": ["sili", "aska"], + "racines": [ + "sili", + "aska" + ], "categorie": "peuple" } ] @@ -31,11 +40,14 @@ "Enfants des Échos": { "traductions": [ { - "confluent": "Nakukeko", + "confluent": "nakukeko", "type": "nom_propre", "composition": "nak-u-keko", "sens_litteral": "Enfants de l'Ă©cho", - "racines": ["naki", "keko"], + "racines": [ + "naki", + "keko" + ], "categorie": "caste", "element": "terre", "racines_sacrees": 0, @@ -46,11 +58,14 @@ "Nakukeko": { "traductions": [ { - "confluent": "Nakukeko", + "confluent": "nakukeko", "type": "nom_propre", "composition": "nak-u-keko", "sens_litteral": "Enfants de l'Ă©cho", - "racines": ["naki", "keko"], + "racines": [ + "naki", + "keko" + ], "categorie": "caste", "element": "terre" } @@ -59,11 +74,14 @@ "Enfants du Courant": { "traductions": [ { - "confluent": "Nakuura", + "confluent": "nakuura", "type": "nom_propre", "composition": "nak-u-ura", "sens_litteral": "Enfants de l'eau", - "racines": ["naki", "ura"], + "racines": [ + "naki", + "ura" + ], "categorie": "caste", "element": "eau", "racines_sacrees": 1, @@ -74,11 +92,14 @@ "Nakuura": { "traductions": [ { - "confluent": "Nakuura", + "confluent": "nakuura", "type": "nom_propre", "composition": "nak-u-ura", "sens_litteral": "Enfants de l'eau", - "racines": ["naki", "ura"], + "racines": [ + "naki", + "ura" + ], "categorie": "caste", "element": "eau" } @@ -87,11 +108,14 @@ "Ailes-Grises": { "traductions": [ { - "confluent": "Aliaska", + "confluent": "aliaska", "type": "nom_propre", "composition": "al-i-aska", "sens_litteral": "Porteurs de la grue libre", - "racines": ["alu", "aska"], + "racines": [ + "alu", + "aska" + ], "categorie": "caste", "element": "air", "racines_sacrees": 2, @@ -102,11 +126,14 @@ "Aliaska": { "traductions": [ { - "confluent": "Aliaska", + "confluent": "aliaska", "type": "nom_propre", "composition": "al-i-aska", "sens_litteral": "Porteurs de la grue libre", - "racines": ["alu", "aska"], + "racines": [ + "alu", + "aska" + ], "categorie": "caste", "element": "air" } @@ -115,11 +142,14 @@ "Faucons Chasseurs": { "traductions": [ { - "confluent": "Akoazana", + "confluent": "akoazana", "type": "nom_propre", "composition": "ak-oa-zana", "sens_litteral": "Faucon vainqueur de la chasse", - "racines": ["aki", "zana"], + "racines": [ + "aki", + "zana" + ], "categorie": "caste", "element": "feu", "racines_sacrees": 1, @@ -130,11 +160,14 @@ "Akoazana": { "traductions": [ { - "confluent": "Akoazana", + "confluent": "akoazana", "type": "nom_propre", "composition": "ak-oa-zana", "sens_litteral": "Faucon vainqueur de la chasse", - "racines": ["aki", "zana"], + "racines": [ + "aki", + "zana" + ], "categorie": "caste", "element": "feu" } @@ -143,11 +176,14 @@ "Passes-bien": { "traductions": [ { - "confluent": "Takitosa", + "confluent": "takitosa", "type": "nom_propre", "composition": "tak-i-tosa", "sens_litteral": "Porteurs du bien", - "racines": ["taka", "tosa"], + "racines": [ + "taka", + "tosa" + ], "categorie": "caste", "element": "ether", "racines_sacrees": 0, @@ -158,11 +194,14 @@ "Takitosa": { "traductions": [ { - "confluent": "Takitosa", + "confluent": "takitosa", "type": "nom_propre", "composition": "tak-i-tosa", "sens_litteral": "Porteurs du bien", - "racines": ["taka", "tosa"], + "racines": [ + "taka", + "tosa" + ], "categorie": "caste", "element": "ether" } @@ -171,11 +210,14 @@ "Voix de l'Aurore": { "traductions": [ { - "confluent": "Oraumi", + "confluent": "oraumi", "type": "nom_propre", "composition": "or-a-umi", "sens_litteral": "Aurore avec esprit", - "racines": ["ora", "umi"], + "racines": [ + "ora", + "umi" + ], "categorie": "groupe_spirituel", "racines_sacrees": 2, "note": "Chamans, gardiens des lois sacrĂ©es" @@ -185,11 +227,14 @@ "Oraumi": { "traductions": [ { - "confluent": "Oraumi", + "confluent": "oraumi", "type": "nom_propre", "composition": "or-a-umi", "sens_litteral": "Aurore avec esprit", - "racines": ["ora", "umi"], + "racines": [ + "ora", + "umi" + ], "categorie": "groupe_spirituel" } ] @@ -197,11 +242,14 @@ "Ciels-clairs": { "traductions": [ { - "confluent": "Zerusora", + "confluent": "zerusora", "type": "composition", "composition": "zer-u-sora", "sens_litteral": "Ciel de lumiĂšre", - "racines": ["zeru", "sora"], + "racines": [ + "zeru", + "sora" + ], "categorie": "groupe_social", "note": "NĂ©s sous ciel dĂ©gagĂ©, yeux aux couleurs de l'aurore" } @@ -210,11 +258,14 @@ "Sans-ciels": { "traductions": [ { - "confluent": "Zozeru", + "confluent": "zozeru", "type": "composition", "composition": "zo-zeru", "sens_litteral": "Sans ciel", - "racines": ["zo", "zeru"], + "racines": [ + "zo", + "zeru" + ], "categorie": "groupe_social", "note": "NĂ©s sous ciel couvert" } @@ -223,11 +274,14 @@ "Gardiens de la Confluence": { "traductions": [ { - "confluent": "Zakiuraakota", + "confluent": "zakiuraakota", "type": "composition", "composition": "zak-i-uraakota", "sens_litteral": "Gardiens de la Confluence", - "racines": ["zaki", "uraakota"], + "racines": [ + "zaki", + "uraakota" + ], "categorie": "titre" } ] @@ -235,11 +289,14 @@ "Caste de l'Air": { "traductions": [ { - "confluent": "Venaakota", + "confluent": "venaakota", "type": "composition", "composition": "ven-aa-kota", "sens_litteral": "Air mĂȘlĂ© Ă  union", - "racines": ["vena", "kota"], + "racines": [ + "vena", + "kota" + ], "categorie": "caste_element" } ] @@ -247,11 +304,14 @@ "Caste du Feu": { "traductions": [ { - "confluent": "Sukiaakota", + "confluent": "sukiaakota", "type": "composition", "composition": "suk-aa-kota", "sens_litteral": "Feu mĂȘlĂ© Ă  union", - "racines": ["suki", "kota"], + "racines": [ + "suki", + "kota" + ], "categorie": "caste_element" } ] @@ -259,11 +319,14 @@ "Caste de l'Eau": { "traductions": [ { - "confluent": "Uraakota", + "confluent": "uraakota", "type": "composition", "composition": "ur-aa-kota", "sens_litteral": "Eau mĂȘlĂ©e Ă  union", - "racines": ["ura", "kota"], + "racines": [ + "ura", + "kota" + ], "categorie": "caste_element", "note": "MĂȘme nom que La Confluence" } @@ -272,11 +335,14 @@ "Caste de la Terre": { "traductions": [ { - "confluent": "Tokaakota", + "confluent": "tokaakota", "type": "composition", "composition": "tok-aa-kota", "sens_litteral": "Terre mĂȘlĂ©e Ă  union", - "racines": ["toka", "kota"], + "racines": [ + "toka", + "kota" + ], "categorie": "caste_element" } ] @@ -284,11 +350,14 @@ "Caste de l'Éther": { "traductions": [ { - "confluent": "Umiaakota", + "confluent": "umiaakota", "type": "composition", "composition": "um-aa-kota", "sens_litteral": "Esprit mĂȘlĂ© Ă  union", - "racines": ["umi", "kota"], + "racines": [ + "umi", + "kota" + ], "categorie": "caste_element" } ] diff --git a/ancien-confluent/lexique/04-lieux.json b/ancien-confluent/lexique/04-lieux.json index 42277d2..0ec298d 100644 --- a/ancien-confluent/lexique/04-lieux.json +++ b/ancien-confluent/lexique/04-lieux.json @@ -5,11 +5,14 @@ "La Confluence": { "traductions": [ { - "confluent": "Uraakota", + "confluent": "uraakota", "type": "nom_propre", "composition": "ur-aa-kota", "sens_litteral": "Eau mĂȘlĂ©e Ă  l'union", - "racines": ["ura", "kota"], + "racines": [ + "ura", + "kota" + ], "categorie": "lieu_majeur", "note": "Lieu central oĂč deux riviĂšres se rejoignent" } @@ -18,11 +21,14 @@ "Uraakota": { "traductions": [ { - "confluent": "Uraakota", + "confluent": "uraakota", "type": "nom_propre", "composition": "ur-aa-kota", "sens_litteral": "Eau mĂȘlĂ©e Ă  l'union", - "racines": ["ura", "kota"], + "racines": [ + "ura", + "kota" + ], "categorie": "lieu_majeur" } ] @@ -30,11 +36,14 @@ "Gouffre Humide": { "traductions": [ { - "confluent": "Vukuura", + "confluent": "vukuura", "type": "nom_propre", "composition": "vuk-u-ura", "sens_litteral": "Gouffre de l'eau", - "racines": ["vuku", "ura"], + "racines": [ + "vuku", + "ura" + ], "categorie": "lieu_majeur", "note": "Lieu sacrĂ© souterrain" } @@ -43,11 +52,14 @@ "Vukuura": { "traductions": [ { - "confluent": "Vukuura", + "confluent": "vukuura", "type": "nom_propre", "composition": "vuk-u-ura", "sens_litteral": "Gouffre de l'eau", - "racines": ["vuku", "ura"], + "racines": [ + "vuku", + "ura" + ], "categorie": "lieu_majeur" } ] @@ -55,11 +67,14 @@ "Antres des Échos": { "traductions": [ { - "confluent": "Kekutoka", + "confluent": "kekutoka", "type": "nom_propre", "composition": "kek-u-toka", "sens_litteral": "Écho de la terre", - "racines": ["keko", "toka"], + "racines": [ + "keko", + "toka" + ], "categorie": "lieu_majeur", "note": "Grottes souterraines" } @@ -68,11 +83,14 @@ "Kekutoka": { "traductions": [ { - "confluent": "Kekutoka", + "confluent": "kekutoka", "type": "nom_propre", "composition": "kek-u-toka", "sens_litteral": "Écho de la terre", - "racines": ["keko", "toka"], + "racines": [ + "keko", + "toka" + ], "categorie": "lieu_majeur" } ] @@ -80,11 +98,14 @@ "Cercles de Vigile": { "traductions": [ { - "confluent": "Sikuvela", + "confluent": "sikuvela", "type": "nom_propre", "composition": "sik-u-vela", "sens_litteral": "Cercle de la vigile", - "racines": ["siku", "vela"], + "racines": [ + "siku", + "vela" + ], "categorie": "lieu_majeur", "note": "Promontoires de guet" } @@ -93,11 +114,14 @@ "Sikuvela": { "traductions": [ { - "confluent": "Sikuvela", + "confluent": "sikuvela", "type": "nom_propre", "composition": "sik-u-vela", "sens_litteral": "Cercle de la vigile", - "racines": ["siku", "vela"], + "racines": [ + "siku", + "vela" + ], "categorie": "lieu_majeur" } ] @@ -105,11 +129,14 @@ "Halls des Serments": { "traductions": [ { - "confluent": "Talusavu", + "confluent": "talusavu", "type": "nom_propre", "composition": "tal-u-savu", "sens_litteral": "Hall du serment", - "racines": ["talu", "savu"], + "racines": [ + "talu", + "savu" + ], "categorie": "lieu_majeur", "note": "Structures gouvernementales" } @@ -118,11 +145,14 @@ "Talusavu": { "traductions": [ { - "confluent": "Talusavu", + "confluent": "talusavu", "type": "nom_propre", "composition": "tal-u-savu", "sens_litteral": "Hall du serment", - "racines": ["talu", "savu"], + "racines": [ + "talu", + "savu" + ], "categorie": "lieu_majeur" } ] @@ -130,11 +160,14 @@ "Grande Fresque": { "traductions": [ { - "confluent": "Ekakova", + "confluent": "ekakova", "type": "nom_propre", "composition": "ek-a-kova", "sens_litteral": "TotalitĂ© avec peinture", - "racines": ["eka", "kova"], + "racines": [ + "eka", + "kova" + ], "categorie": "lieu_majeur", "note": "Artefact multi-gĂ©nĂ©rationnel" } @@ -143,11 +176,14 @@ "Ekakova": { "traductions": [ { - "confluent": "Ekakova", + "confluent": "ekakova", "type": "nom_propre", "composition": "ek-a-kova", "sens_litteral": "TotalitĂ© avec peinture", - "racines": ["eka", "kova"], + "racines": [ + "eka", + "kova" + ], "categorie": "lieu_majeur" } ] @@ -155,11 +191,14 @@ "Gorge Profonde": { "traductions": [ { - "confluent": "Vukumako", + "confluent": "vukumako", "type": "composition", "composition": "vuk-u-mako", "sens_litteral": "Gouffre de grandeur", - "racines": ["vuku", "mako"], + "racines": [ + "vuku", + "mako" + ], "categorie": "lieu" } ] @@ -167,11 +206,14 @@ "Ruines des Premiers AncĂȘtres": { "traductions": [ { - "confluent": "Osiuaita", + "confluent": "osiuaita", "type": "composition", "composition": "os-i-aita", "sens_litteral": "Mort des ancĂȘtres", - "racines": ["osi", "aita"], + "racines": [ + "osi", + "aita" + ], "categorie": "lieu_sacre", "note": "Vestiges de la civilisation disparue" } @@ -184,7 +226,10 @@ "type": "composition", "composition": "kot-a-zaki", "sens_litteral": "Union avec protection", - "racines": ["kota", "zaki"], + "racines": [ + "kota", + "zaki" + ], "categorie": "structure" } ] @@ -196,7 +241,10 @@ "type": "composition", "composition": "tok-u-vuku", "sens_litteral": "Terre du bas", - "racines": ["toka", "vuku"], + "racines": [ + "toka", + "vuku" + ], "categorie": "region" } ] @@ -208,7 +256,10 @@ "type": "composition", "composition": "vel-a-meru", "sens_litteral": "Vigile avec mer", - "racines": ["vela", "meru"], + "racines": [ + "vela", + "meru" + ], "categorie": "structure" } ] @@ -220,7 +271,10 @@ "type": "composition", "composition": "as-a-loku", "sens_litteral": "SacrĂ© avec lieu", - "racines": ["asa", "loku"], + "racines": [ + "asa", + "loku" + ], "categorie": "structure" } ] @@ -232,7 +286,10 @@ "type": "composition", "composition": "zak-i-kari", "sens_litteral": "Protection de pierre", - "racines": ["zaki", "kari"], + "racines": [ + "zaki", + "kari" + ], "categorie": "structure" } ] diff --git a/ancien-confluent/lexique/06-actions.json b/ancien-confluent/lexique/06-actions.json index 8e04770..ff23db5 100644 --- a/ancien-confluent/lexique/06-actions.json +++ b/ancien-confluent/lexique/06-actions.json @@ -570,6 +570,21 @@ "note": "Manger violemment, comme un prĂ©dateur" } ] + }, + "exister": { + "racine_fr": "exist", + "traductions": [ + { + "confluent": "urak", + "type": "verbe_irregulier", + "racine": "ura", + "forme_liee": "ur", + "structure": "VCVC", + "domaine": "action_existentielle", + "note": "Verbe irrĂ©gulier existentiel - 'il y a', prĂ©sence, existence. DĂ©rivĂ© de la racine sacrĂ©e 'ura' (eau/flux vital)" + } + ], + "synonymes_fr": ["il y a", "y a-t-il", "existe", "existent", "existant"] } } } diff --git a/ancien-confluent/lexique/09-institutions.json b/ancien-confluent/lexique/09-institutions.json index 68c18eb..f4d60fc 100644 --- a/ancien-confluent/lexique/09-institutions.json +++ b/ancien-confluent/lexique/09-institutions.json @@ -5,11 +5,15 @@ "Cercle des Sages": { "traductions": [ { - "confluent": "Rikuusekitori", + "confluent": "rikuusekitori", "type": "nom_propre", "composition": "sik-u-sek-i-tori", "sens_litteral": "Cercle des porteurs-de-savoir", - "racines": ["siku", "seka", "tori"], + "racines": [ + "siku", + "seka", + "tori" + ], "categorie": "institution", "note": "Institution centrale" } @@ -18,11 +22,14 @@ "Tribunal des MƓurs": { "traductions": [ { - "confluent": "Verimuloku", + "confluent": "verimuloku", "type": "nom_propre", "composition": "ver-i-m-loku", "sens_litteral": "Lieu de vĂ©ritĂ© des mƓurs", - "racines": ["veri", "loku"], + "racines": [ + "veri", + "loku" + ], "categorie": "institution" } ] @@ -30,11 +37,14 @@ "Proclamateur": { "traductions": [ { - "confluent": "Vokiueka", + "confluent": "vokiueka", "type": "nom_propre", "composition": "vok-i-eka", "sens_litteral": "Voix de la totalitĂ©", - "racines": ["voki", "eka"], + "racines": [ + "voki", + "eka" + ], "categorie": "titre" } ] @@ -42,11 +52,14 @@ "AssemblĂ©e des Chefs": { "traductions": [ { - "confluent": "Kotaukasi", + "confluent": "kotaukasi", "type": "nom_propre", "composition": "kot-a-kasi", "sens_litteral": "Union avec les chefs", - "racines": ["kota", "kasi"], + "racines": [ + "kota", + "kasi" + ], "categorie": "institution" } ] @@ -54,11 +67,14 @@ "Maison des DĂ©couvertes": { "traductions": [ { - "confluent": "Nutuumiris", + "confluent": "nutuumiris", "type": "nom_propre", "composition": "nut-u-miris", "sens_litteral": "Maison de la dĂ©couverte", - "racines": ["nutu", "miris"], + "racines": [ + "nutu", + "miris" + ], "categorie": "institution" } ] @@ -66,11 +82,14 @@ "Arbitre des Esprits": { "traductions": [ { - "confluent": "Zakiiumi", + "confluent": "zakiiumi", "type": "nom_propre", "composition": "zak-ii-umi", "sens_litteral": "Celui qui EST gardien des esprits", - "racines": ["zaki", "umi"], + "racines": [ + "zaki", + "umi" + ], "categorie": "titre_supreme", "note": "EntitĂ© tutĂ©laire du jeu, pouvoir de rĂ©serve" } @@ -79,11 +98,14 @@ "Directoire": { "traductions": [ { - "confluent": "Kasiiukota", + "confluent": "kasiiukota", "type": "nom_propre", "composition": "kas-ii-kota", "sens_litteral": "Chefs unis", - "racines": ["kasi", "kota"], + "racines": [ + "kasi", + "kota" + ], "categorie": "institution" } ] @@ -91,11 +113,14 @@ "Hall des Serments": { "traductions": [ { - "confluent": "Talusavu", + "confluent": "talusavu", "type": "nom_propre", "composition": "tal-u-savu", "sens_litteral": "Hall du serment", - "racines": ["talu", "savu"], + "racines": [ + "talu", + "savu" + ], "categorie": "lieu_institution" } ] @@ -103,11 +128,15 @@ "Conseil du Village": { "traductions": [ { - "confluent": "Kotaurikusi", + "confluent": "kotaurikusi", "type": "composition", "composition": "kot-a-sik-u-si", "sens_litteral": "Union avec cercle de regard", - "racines": ["kota", "siku", "sili"], + "racines": [ + "kota", + "siku", + "sili" + ], "categorie": "institution" } ] @@ -115,11 +144,14 @@ "Autel ancestral": { "traductions": [ { - "confluent": "Asauaita", + "confluent": "asauaita", "type": "composition", "composition": "as-a-aita", "sens_litteral": "SacrĂ© avec ancĂȘtre", - "racines": ["asa", "aita"], + "racines": [ + "asa", + "aita" + ], "categorie": "lieu_sacre" } ] @@ -127,11 +159,14 @@ "Vigile Lunaire": { "traductions": [ { - "confluent": "Velauluna", + "confluent": "velauluna", "type": "composition", "composition": "vel-a-luna", "sens_litteral": "Vigile avec lune", - "racines": ["vela", "luna"], + "racines": [ + "vela", + "luna" + ], "categorie": "rituel" } ] @@ -139,11 +174,14 @@ "Jour des AncĂȘtres": { "traductions": [ { - "confluent": "Sorauaita", + "confluent": "sorauaita", "type": "composition", "composition": "sor-a-aita", "sens_litteral": "Jour avec ancĂȘtres", - "racines": ["sora", "aita"], + "racines": [ + "sora", + "aita" + ], "categorie": "celebration" } ] @@ -151,11 +189,14 @@ "Jour du Faucon": { "traductions": [ { - "confluent": "Sorauaki", + "confluent": "sorauaki", "type": "composition", "composition": "sor-a-aki", "sens_litteral": "Jour avec faucon", - "racines": ["sora", "aki"], + "racines": [ + "sora", + "aki" + ], "categorie": "celebration" } ] diff --git a/ancien-confluent/lexique/10-animaux.json b/ancien-confluent/lexique/10-animaux.json index d8c7560..df2f15f 100644 --- a/ancien-confluent/lexique/10-animaux.json +++ b/ancien-confluent/lexique/10-animaux.json @@ -12,16 +12,21 @@ "note": "Animal sacrĂ© central dans la culture" } ], - "synonymes_fr": ["grues"] + "synonymes_fr": [ + "grues" + ] }, "Regards-Libres": { "traductions": [ { - "confluent": "Aruaska", + "confluent": "aruaska", "type": "composition", "composition": "al-u-aska", "sens_litteral": "Grue de libertĂ©", - "racines": ["alu", "aska"], + "racines": [ + "alu", + "aska" + ], "categorie": "animal_sacre", "note": "Grues domestiquĂ©es, messagers sacrĂ©s" } @@ -30,11 +35,14 @@ "grue cendrĂ©e": { "traductions": [ { - "confluent": "Arusenu", + "confluent": "arusenu", "type": "composition", "composition": "al-u-senu", "sens_litteral": "Grue de cendre", - "racines": ["alu", "senu"], + "racines": [ + "alu", + "senu" + ], "categorie": "animal" } ] @@ -60,7 +68,9 @@ "note": "Animal gĂ©nĂ©rique" } ], - "synonymes_fr": ["animal"] + "synonymes_fr": [ + "animal" + ] }, "bĂȘte sacrĂ©e": { "traductions": [ @@ -69,7 +79,10 @@ "type": "composition", "composition": "as-a-betu", "sens_litteral": "SacrĂ© avec bĂȘte", - "racines": ["asa", "betu"], + "racines": [ + "asa", + "betu" + ], "categorie": "animal_sacre" } ] @@ -81,7 +94,10 @@ "type": "composition", "composition": "zan-u-betu", "sens_litteral": "BĂȘte de chasse", - "racines": ["zana", "betu"], + "racines": [ + "zana", + "betu" + ], "domaine": "animal" } ] @@ -104,7 +120,10 @@ "type": "composition", "composition": "pis-u-nura", "sens_litteral": "Poisson de riviĂšre", - "racines": ["pisu", "nura"], + "racines": [ + "pisu", + "nura" + ], "domaine": "animal" } ] @@ -127,7 +146,10 @@ "type": "composition", "composition": "sep-u-ura", "sens_litteral": "Serpent de l'eau", - "racines": ["sepu", "ura"], + "racines": [ + "sepu", + "ura" + ], "domaine": "animal" } ] @@ -150,7 +172,10 @@ "type": "composition", "composition": "ap-i-zana", "sens_litteral": "Oiseau de chasse", - "racines": ["apo", "zana"], + "racines": [ + "apo", + "zana" + ], "domaine": "animal" } ] @@ -162,7 +187,10 @@ "type": "composition", "composition": "zo-mira", "sens_litteral": "Sans vue", - "racines": ["zo", "mira"], + "racines": [ + "zo", + "mira" + ], "domaine": "animal", "note": "CrĂ©ature jamais observĂ©e" } @@ -186,7 +214,9 @@ "type": "composition", "composition": "loku + su", "sens_litteral": "Loups (pluriel)", - "racines": ["loku"], + "racines": [ + "loku" + ], "domaine": "animal" } ] diff --git a/ancien-confluent/lexique/12-abstraits.json b/ancien-confluent/lexique/12-abstraits.json index a207fbf..cdeff13 100644 --- a/ancien-confluent/lexique/12-abstraits.json +++ b/ancien-confluent/lexique/12-abstraits.json @@ -9,7 +9,10 @@ "type": "composition", "composition": "sil-i-aska", "sens_litteral": "Regard de libertĂ©", - "racines": ["sili", "aska"], + "racines": [ + "sili", + "aska" + ], "domaine": "concept_fondateur", "note": "État spirituel central" } @@ -25,7 +28,9 @@ "note": "Union, rencontre" } ], - "synonymes_fr": ["union"] + "synonymes_fr": [ + "union" + ] }, "harmonie": { "traductions": [ @@ -34,7 +39,10 @@ "type": "composition", "composition": "kot-a-tosa", "sens_litteral": "Union avec le bien", - "racines": ["kota", "tosa"], + "racines": [ + "kota", + "tosa" + ], "domaine": "concept_abstrait" } ] @@ -46,7 +54,10 @@ "type": "composition", "composition": "sek-a-aita", "sens_litteral": "Savoir des ancĂȘtres", - "racines": ["seka", "aita"], + "racines": [ + "seka", + "aita" + ], "domaine": "concept_abstrait" } ] @@ -58,7 +69,10 @@ "type": "composition", "composition": "val-u-veri", "sens_litteral": "Valeur de vĂ©ritĂ©", - "racines": ["valu", "veri"], + "racines": [ + "valu", + "veri" + ], "domaine": "concept_abstrait" } ] @@ -70,7 +84,10 @@ "type": "composition", "composition": "ver-i-kota", "sens_litteral": "VĂ©ritĂ© de l'union", - "racines": ["veri", "kota"], + "racines": [ + "veri", + "kota" + ], "domaine": "concept_abstrait" } ] @@ -104,7 +121,9 @@ "domaine": "concept_fondateur" } ], - "synonymes_fr": ["Ăąme"] + "synonymes_fr": [ + "Ăąme" + ] }, "destinĂ©e": { "traductions": [ @@ -113,7 +132,10 @@ "type": "composition", "composition": "tek-i-umi", "sens_litteral": "Chemin de l'esprit", - "racines": ["teki", "umi"], + "racines": [ + "teki", + "umi" + ], "domaine": "concept_abstrait" } ] @@ -125,7 +147,10 @@ "type": "composition", "composition": "as-a-neka", "sens_litteral": "SacrĂ© avec Ɠuvre", - "racines": ["asa", "neka"], + "racines": [ + "asa", + "neka" + ], "domaine": "concept_abstrait" } ] @@ -137,7 +162,10 @@ "type": "composition", "composition": "sek-a-tosa", "sens_litteral": "Savoir avec bien", - "racines": ["seka", "tosa"], + "racines": [ + "seka", + "tosa" + ], "domaine": "concept_abstrait" } ] @@ -149,7 +177,10 @@ "type": "composition", "composition": "kis-u-n-aita", "sens_litteral": "Enseignement des ancĂȘtres", - "racines": ["kisu", "aita"], + "racines": [ + "kisu", + "aita" + ], "domaine": "concept_abstrait" } ] @@ -157,25 +188,32 @@ "L'Autre": { "traductions": [ { - "confluent": "Tova", + "confluent": "tova", "type": "nom_propre", "composition": "tova", "sens_litteral": "Celui de loin", - "racines": ["tova"], + "racines": [ + "tova" + ], "domaine": "social", "note": "L'Ă©tranger, celui qui n'est pas du peuple" } ], - "synonymes_fr": ["Ă©tranger"] + "synonymes_fr": [ + "Ă©tranger" + ] }, "Premiers AncĂȘtres": { "traductions": [ { - "confluent": "Enuaita", + "confluent": "enuaita", "type": "nom_propre", "composition": "en-u-aita", "sens_litteral": "Origine des ancĂȘtres", - "racines": ["ena", "aita"], + "racines": [ + "ena", + "aita" + ], "domaine": "spirituel" } ] @@ -187,7 +225,10 @@ "type": "composition", "composition": "sil-u-novi", "sens_litteral": "Regard du nouveau", - "racines": ["sili", "novi"], + "racines": [ + "sili", + "novi" + ], "domaine": "spirituel" } ] @@ -199,7 +240,10 @@ "type": "composition", "composition": "ven-u-zoka", "sens_litteral": "Air de l'ennemi", - "racines": ["vena", "zoka"], + "racines": [ + "vena", + "zoka" + ], "domaine": "danger" } ] @@ -211,7 +255,10 @@ "type": "composition", "composition": "as-a-tosa", "sens_litteral": "SacrĂ© avec bien", - "racines": ["asa", "tosa"], + "racines": [ + "asa", + "tosa" + ], "domaine": "spirituel" } ] @@ -223,7 +270,10 @@ "type": "composition", "composition": "as-a-zoka", "sens_litteral": "SacrĂ© avec ennemi", - "racines": ["asa", "zoka"], + "racines": [ + "asa", + "zoka" + ], "domaine": "spirituel" } ] @@ -235,7 +285,10 @@ "type": "composition", "composition": "kot-a-neka", "sens_litteral": "Union avec Ɠuvre", - "racines": ["kota", "neka"], + "racines": [ + "kota", + "neka" + ], "domaine": "social" } ] @@ -261,7 +314,9 @@ "note": "Groupe de sang" } ], - "synonymes_fr": ["clan"] + "synonymes_fr": [ + "clan" + ] }, "gĂ©nĂ©alogie": { "traductions": [ @@ -270,7 +325,10 @@ "type": "composition", "composition": "mit-u-aita", "sens_litteral": "Famille des ancĂȘtres", - "racines": ["mitu", "aita"], + "racines": [ + "mitu", + "aita" + ], "domaine": "social" } ] @@ -293,7 +351,10 @@ "type": "composition", "composition": "sav-u-pasu", "sens_litteral": "Serment du sang", - "racines": ["savu", "pasu"], + "racines": [ + "savu", + "pasu" + ], "domaine": "institution" } ] @@ -315,7 +376,10 @@ "type": "composition", "composition": "lok-u-asa", "sens_litteral": "Loi du sacrĂ©", - "racines": ["loku", "asa"], + "racines": [ + "loku", + "asa" + ], "domaine": "institution" } ] @@ -337,7 +401,10 @@ "type": "composition", "composition": "ok-i-veri", "sens_litteral": "Épreuve de vĂ©ritĂ©", - "racines": ["oki", "veri"], + "racines": [ + "oki", + "veri" + ], "domaine": "institution" } ] @@ -349,7 +416,10 @@ "type": "composition", "composition": "zo-savu", "sens_litteral": "Sans serment", - "racines": ["zo", "savu"], + "racines": [ + "zo", + "savu" + ], "domaine": "concept_negatif" } ] @@ -361,7 +431,10 @@ "type": "composition", "composition": "zo-kota", "sens_litteral": "Sans union", - "racines": ["zo", "kota"], + "racines": [ + "zo", + "kota" + ], "domaine": "concept_negatif" } ] @@ -376,6 +449,22 @@ } ] }, + "ennemi": { + "traductions": [ + { + "confluent": "zoka", + "type": "racine", + "forme_liee": "zok", + "domaine": "conflit", + "note": "Adversaire, hostile, mal" + } + ], + "synonymes_fr": [ + "adversaire", + "hostile", + "malveillant" + ] + }, "paix": { "traductions": [ { @@ -393,7 +482,10 @@ "type": "composition", "composition": "ok-i-a-tosa", "sens_litteral": "Épreuve avec bien", - "racines": ["oki", "tosa"], + "racines": [ + "oki", + "tosa" + ], "domaine": "conflit" } ] @@ -405,7 +497,10 @@ "type": "composition", "composition": "ok-i-a-zoka", "sens_litteral": "Épreuve avec mal", - "racines": ["oki", "zoka"], + "racines": [ + "oki", + "zoka" + ], "domaine": "conflit" } ] @@ -417,7 +512,10 @@ "type": "composition", "composition": "os-i-a-zoka", "sens_litteral": "Mort avec hostilitĂ©", - "racines": ["osi", "zoka"], + "racines": [ + "osi", + "zoka" + ], "domaine": "concept_negatif" } ] @@ -429,7 +527,10 @@ "type": "composition", "composition": "bet-u-zoka", "sens_litteral": "BĂȘte de l'hostilitĂ©", - "racines": ["betu", "zoka"], + "racines": [ + "betu", + "zoka" + ], "domaine": "concept_negatif" } ] @@ -441,7 +542,10 @@ "type": "composition", "composition": "zok-u-zana", "sens_litteral": "Secret de chasse", - "racines": ["zoku", "zana"], + "racines": [ + "zoku", + "zana" + ], "domaine": "conflit" } ] @@ -453,7 +557,10 @@ "type": "composition", "composition": "pas-ik-i-tori", "sens_litteral": "Personne capturĂ©e", - "racines": ["pasik", "tori"], + "racines": [ + "pasik", + "tori" + ], "domaine": "conflit" } ] diff --git a/ancien-confluent/lexique/13-rituels.json b/ancien-confluent/lexique/13-rituels.json index 734e197..cf25193 100644 --- a/ancien-confluent/lexique/13-rituels.json +++ b/ancien-confluent/lexique/13-rituels.json @@ -5,11 +5,15 @@ "Rituel du Regard PartagĂ©": { "traductions": [ { - "confluent": "Asausiliaakota", + "confluent": "asausiliaakota", "type": "nom_propre", "composition": "as-a-sil-aa-kota", "sens_litteral": "SacrĂ© avec regard-mĂȘlĂ©-Ă -union", - "racines": ["asa", "sili", "kota"], + "racines": [ + "asa", + "sili", + "kota" + ], "categorie": "rituel_majeur", "note": "Rituel central de la civilisation" } @@ -22,7 +26,10 @@ "type": "composition", "composition": "tek-i-asa", "sens_litteral": "Chemin du sacrĂ©", - "racines": ["teki", "asa"], + "racines": [ + "teki", + "asa" + ], "domaine": "rituel" } ] @@ -34,7 +41,10 @@ "type": "composition", "composition": "as-a-osi", "sens_litteral": "SacrĂ© avec mort", - "racines": ["asa", "osi"], + "racines": [ + "asa", + "osi" + ], "domaine": "rituel" } ] @@ -42,11 +52,14 @@ "Cercles de Vigile": { "traductions": [ { - "confluent": "Sikuvela", + "confluent": "sikuvela", "type": "nom_propre", "composition": "sik-u-vela", "sens_litteral": "Cercle de la vigile", - "racines": ["siku", "vela"], + "racines": [ + "siku", + "vela" + ], "categorie": "rituel" } ] @@ -54,11 +67,14 @@ "Communion des esprits": { "traductions": [ { - "confluent": "Kotamuumi", + "confluent": "kotamuumi", "type": "nom_propre", "composition": "kot-a-m-umi", "sens_litteral": "Union avec esprits", - "racines": ["kota", "umi"], + "racines": [ + "kota", + "umi" + ], "categorie": "rituel" } ] @@ -66,11 +82,15 @@ "Lois du Sang et de la BĂȘte": { "traductions": [ { - "confluent": "Lokuurasubetu", + "confluent": "lokuurasubetu", "type": "nom_propre", "composition": "lok-u-pasu-betu", "sens_litteral": "Loi du sang et de la bĂȘte", - "racines": ["loku", "pasu", "betu"], + "racines": [ + "loku", + "pasu", + "betu" + ], "categorie": "loi_sacree" } ] @@ -78,11 +98,14 @@ "Porteur de Flamme": { "traductions": [ { - "confluent": "Takiusuki", + "confluent": "takiusuki", "type": "nom_propre", "composition": "tak-i-suki", "sens_litteral": "Porteur du feu", - "racines": ["taka", "suki"], + "racines": [ + "taka", + "suki" + ], "categorie": "titre_rituel" } ] @@ -90,11 +113,14 @@ "MĂ©mento": { "traductions": [ { - "confluent": "Memuuaita", + "confluent": "memuuaita", "type": "nom_propre", "composition": "mem-u-aita", "sens_litteral": "MĂ©moire des ancĂȘtres", - "racines": ["memu", "aita"], + "racines": [ + "memu", + "aita" + ], "categorie": "objet_rituel" } ] @@ -106,7 +132,10 @@ "type": "composition", "composition": "sav-u-asa", "sens_litteral": "Serment du sacrĂ©", - "racines": ["savu", "asa"], + "racines": [ + "savu", + "asa" + ], "domaine": "rituel" } ] @@ -114,11 +143,14 @@ "Glyphes du Gouffre": { "traductions": [ { - "confluent": "Kovuuvuku", + "confluent": "kovuuvuku", "type": "nom_propre", "composition": "kov-u-vuku", "sens_litteral": "Gravures du gouffre", - "racines": ["kova", "vuku"], + "racines": [ + "kova", + "vuku" + ], "categorie": "objet_rituel" } ] @@ -130,7 +162,10 @@ "type": "composition", "composition": "kop-u-kova", "sens_litteral": "Corde de gravures", - "racines": ["kopu", "kova"], + "racines": [ + "kopu", + "kova" + ], "domaine": "objet_rituel" } ] @@ -142,7 +177,10 @@ "type": "composition", "composition": "tab-u-toka", "sens_litteral": "Tablette de terre", - "racines": ["tabu", "toka"], + "racines": [ + "tabu", + "toka" + ], "domaine": "objet_rituel" } ] @@ -154,11 +192,16 @@ "type": "composition", "composition": "kov-a-sili", "sens_litteral": "Gravure avec regard", - "racines": ["kova", "sili"], + "racines": [ + "kova", + "sili" + ], "domaine": "communication" } ], - "synonymes_fr": ["Ă©criture"] + "synonymes_fr": [ + "Ă©criture" + ] }, "argile vivante": { "traductions": [ @@ -167,7 +210,10 @@ "type": "composition", "composition": "tok-a-ita", "sens_litteral": "Terre avec vie", - "racines": ["toka", "ita"], + "racines": [ + "toka", + "ita" + ], "domaine": "materiau_rituel" } ] @@ -179,7 +225,10 @@ "type": "composition", "composition": "mil-u-kari", "sens_litteral": "Lait de pierre", - "racines": ["milu", "kari"], + "racines": [ + "milu", + "kari" + ], "domaine": "materiau_rituel" } ] @@ -191,7 +240,10 @@ "type": "composition", "composition": "kar-i-suki", "sens_litteral": "Pierre du feu", - "racines": ["kari", "suki"], + "racines": [ + "kari", + "suki" + ], "domaine": "materiau_rituel" } ] @@ -203,7 +255,10 @@ "type": "composition", "composition": "kol-u-aita", "sens_litteral": "Couleurs des ancĂȘtres", - "racines": ["kolu", "aita"], + "racines": [ + "kolu", + "aita" + ], "domaine": "materiau_rituel" } ] @@ -211,11 +266,14 @@ "Rhombes sacrĂ©s": { "traductions": [ { - "confluent": "Onuuasa", + "confluent": "onuuasa", "type": "nom_propre", "composition": "on-u-asa", "sens_litteral": "Son du sacrĂ©", - "racines": ["onu", "asa"], + "racines": [ + "onu", + "asa" + ], "categorie": "objet_rituel", "note": "Instruments produisant le son sacrĂ©" } @@ -224,11 +282,14 @@ "Rhombes gĂ©ants": { "traductions": [ { - "confluent": "Onuumako", + "confluent": "onuumako", "type": "nom_propre", "composition": "on-u-mako", "sens_litteral": "Son de grandeur", - "racines": ["onu", "mako"], + "racines": [ + "onu", + "mako" + ], "categorie": "objet_rituel" } ] @@ -240,7 +301,10 @@ "type": "composition", "composition": "on-u-pisu", "sens_litteral": "Son petit", - "racines": ["onu", "pisu"], + "racines": [ + "onu", + "pisu" + ], "domaine": "objet_rituel" } ] @@ -252,7 +316,11 @@ "type": "composition", "composition": "nek-a-eka-aita", "sens_litteral": "ƒuvre avec totalitĂ© des ancĂȘtres", - "racines": ["neka", "eka", "aita"], + "racines": [ + "neka", + "eka", + "aita" + ], "domaine": "objet_rituel" } ] @@ -260,11 +328,14 @@ "Grande Fresque": { "traductions": [ { - "confluent": "Ekakova", + "confluent": "ekakova", "type": "nom_propre", "composition": "ek-a-kova", "sens_litteral": "TotalitĂ© avec peinture", - "racines": ["eka", "kova"], + "racines": [ + "eka", + "kova" + ], "categorie": "lieu_rituel" } ] @@ -276,7 +347,10 @@ "type": "composition", "composition": "sil-u-temi", "sens_litteral": "Regard du temps", - "racines": ["sili", "temi"], + "racines": [ + "sili", + "temi" + ], "domaine": "concept_rituel" } ] @@ -284,11 +358,15 @@ "Autel des Pionniers": { "traductions": [ { - "confluent": "Asauenuaita", + "confluent": "asauenuaita", "type": "nom_propre", "composition": "as-a-en-u-aita", "sens_litteral": "SacrĂ© avec origine des ancĂȘtres", - "racines": ["asa", "ena", "aita"], + "racines": [ + "asa", + "ena", + "aita" + ], "categorie": "lieu_rituel" } ] diff --git a/ancien-confluent/lexique/15-roles-titres.json b/ancien-confluent/lexique/15-roles-titres.json index e891e28..1880e6f 100644 --- a/ancien-confluent/lexique/15-roles-titres.json +++ b/ancien-confluent/lexique/15-roles-titres.json @@ -5,11 +5,14 @@ "Arbitre des Esprits": { "traductions": [ { - "confluent": "Zakiiumi", + "confluent": "zakiiumi", "type": "nom_propre", "composition": "zak-ii-umi", "sens_litteral": "Celui qui EST gardien des esprits", - "racines": ["zaki", "umi"], + "racines": [ + "zaki", + "umi" + ], "categorie": "titre_supreme", "note": "EntitĂ© tutĂ©laire du jeu, pouvoir de rĂ©serve" } @@ -22,7 +25,10 @@ "type": "composition", "composition": "sil-u-umi", "sens_litteral": "Regard de l'esprit", - "racines": ["sili", "umi"], + "racines": [ + "sili", + "umi" + ], "domaine": "titre_spirituel" } ] @@ -40,11 +46,14 @@ "Grand Chef": { "traductions": [ { - "confluent": "Makokasi", + "confluent": "makokasi", "type": "nom_propre", "composition": "mak-o-kasi", "sens_litteral": "Chef de grandeur", - "racines": ["mako", "kasi"], + "racines": [ + "mako", + "kasi" + ], "categorie": "titre" } ] @@ -52,11 +61,14 @@ "Proclamateur": { "traductions": [ { - "confluent": "Vokiueka", + "confluent": "vokiueka", "type": "nom_propre", "composition": "vok-i-eka", "sens_litteral": "Voix de la totalitĂ©", - "racines": ["voki", "eka"], + "racines": [ + "voki", + "eka" + ], "categorie": "titre" } ] @@ -68,7 +80,10 @@ "type": "composition", "composition": "sek-i-tori", "sens_litteral": "Porteur de savoir", - "racines": ["seka", "tori"], + "racines": [ + "seka", + "tori" + ], "domaine": "titre" } ] @@ -76,23 +91,35 @@ "Faucon Chasseur": { "traductions": [ { - "confluent": "Akoazana", + "confluent": "akoazana", "type": "nom_propre", "composition": "ak-oa-zana", "sens_litteral": "Faucon vainqueur de la chasse", - "racines": ["aki", "zana"], + "racines": [ + "aki", + "zana" + ], "categorie": "caste" } + ], + "synonymes_fr": [ + "faucon chasseur", + "faucons chasseurs", + "faucon", + "faucons" ] }, "Faucon vĂ©tĂ©ran": { "traductions": [ { - "confluent": "Akiuaita", + "confluent": "akiuaita", "type": "composition", "composition": "ak-i-aita", "sens_litteral": "Faucon des ancĂȘtres", - "racines": ["aki", "aita"], + "racines": [ + "aki", + "aita" + ], "domaine": "titre" } ] @@ -104,9 +131,17 @@ "type": "composition", "composition": "zan-a-tori", "sens_litteral": "Personne de la chasse", - "racines": ["zana", "tori"], + "racines": [ + "zana", + "tori" + ], "domaine": "titre" } + ], + "synonymes_fr": [ + "chasseur", + "chasseurs", + "traqueurs" ] }, "guerrier": { @@ -116,7 +151,10 @@ "type": "composition", "composition": "ok-i-tori", "sens_litteral": "Personne de l'Ă©preuve", - "racines": ["oki", "tori"], + "racines": [ + "oki", + "tori" + ], "domaine": "titre" } ] @@ -128,7 +166,10 @@ "type": "composition", "composition": "ark-u-tori", "sens_litteral": "Personne de l'arc", - "racines": ["arku", "tori"], + "racines": [ + "arku", + "tori" + ], "domaine": "titre" } ] @@ -140,7 +181,10 @@ "type": "composition", "composition": "tak-i-piki", "sens_litteral": "Porteur de lance", - "racines": ["taka", "piki"], + "racines": [ + "taka", + "piki" + ], "domaine": "titre" } ] @@ -152,7 +196,10 @@ "type": "composition", "composition": "kas-i-oki", "sens_litteral": "Chef de l'Ă©preuve", - "racines": ["kasi", "oki"], + "racines": [ + "kasi", + "oki" + ], "domaine": "titre" } ] @@ -164,7 +211,10 @@ "type": "composition", "composition": "vel-a-tori", "sens_litteral": "Personne de vigile", - "racines": ["vela", "tori"], + "racines": [ + "vela", + "tori" + ], "domaine": "titre" } ] @@ -172,13 +222,24 @@ "Aile-Grise": { "traductions": [ { - "confluent": "Aliaska", + "confluent": "aliaska", "type": "nom_propre", "composition": "al-i-aska", "sens_litteral": "Porteur de la grue libre", - "racines": ["alu", "aska"], + "racines": [ + "alu", + "aska" + ], "categorie": "caste" } + ], + "synonymes_fr": [ + "aile-grise", + "ailes-grises", + "aile grise", + "ailes grises", + "aile", + "ailes" ] }, "chaman": { @@ -188,7 +249,10 @@ "type": "composition", "composition": "um-i-tori", "sens_litteral": "Personne de l'esprit", - "racines": ["umi", "tori"], + "racines": [ + "umi", + "tori" + ], "domaine": "titre_spirituel" } ] @@ -200,7 +264,11 @@ "type": "composition", "composition": "al-u-zak-i-tori", "sens_litteral": "Personne gardienne des grues", - "racines": ["alu", "zaki", "tori"], + "racines": [ + "alu", + "zaki", + "tori" + ], "domaine": "titre" } ] @@ -212,7 +280,10 @@ "type": "composition", "composition": "tek-i-umi", "sens_litteral": "Chemin des esprits", - "racines": ["teki", "umi"], + "racines": [ + "teki", + "umi" + ], "domaine": "titre_spirituel" } ] @@ -224,7 +295,10 @@ "type": "composition", "composition": "zak-i-loku", "sens_litteral": "Gardien des lois", - "racines": ["zaki", "loku"], + "racines": [ + "zaki", + "loku" + ], "domaine": "titre" } ] @@ -232,11 +306,14 @@ "Passe-bien": { "traductions": [ { - "confluent": "Takitosa", + "confluent": "takitosa", "type": "nom_propre", "composition": "tak-i-tosa", "sens_litteral": "Porteur du bien", - "racines": ["taka", "tosa"], + "racines": [ + "taka", + "tosa" + ], "categorie": "caste" } ] @@ -244,11 +321,14 @@ "Porteur de Flamme": { "traductions": [ { - "confluent": "Takiusuki", + "confluent": "takiusuki", "type": "nom_propre", "composition": "tak-i-suki", "sens_litteral": "Porteur du feu", - "racines": ["taka", "suki"], + "racines": [ + "taka", + "suki" + ], "categorie": "titre_rituel" } ] @@ -260,7 +340,10 @@ "type": "composition", "composition": "mak-o-neka", "sens_litteral": "Grand de l'Ɠuvre", - "racines": ["mako", "neka"], + "racines": [ + "mako", + "neka" + ], "domaine": "titre" } ] @@ -272,7 +355,10 @@ "type": "composition", "composition": "nek-a-kari", "sens_litteral": "Faiseur avec pierre", - "racines": ["neka", "kari"], + "racines": [ + "neka", + "kari" + ], "domaine": "titre" } ] @@ -284,7 +370,10 @@ "type": "composition", "composition": "kov-a-tori", "sens_litteral": "Personne de la gravure", - "racines": ["kova", "tori"], + "racines": [ + "kova", + "tori" + ], "domaine": "titre" } ] @@ -296,7 +385,10 @@ "type": "composition", "composition": "kol-u-tori", "sens_litteral": "Personne des couleurs", - "racines": ["kolu", "tori"], + "racines": [ + "kolu", + "tori" + ], "domaine": "titre" } ] @@ -308,7 +400,10 @@ "type": "composition", "composition": "vas-i-tori", "sens_litteral": "Personne du tissage", - "racines": ["vasi", "tori"], + "racines": [ + "vasi", + "tori" + ], "domaine": "titre" } ] @@ -320,7 +415,10 @@ "type": "composition", "composition": "pis-u-tori", "sens_litteral": "Personne du poisson", - "racines": ["pisu", "tori"], + "racines": [ + "pisu", + "tori" + ], "domaine": "titre" } ] @@ -332,7 +430,10 @@ "type": "composition", "composition": "vuk-u-tori", "sens_litteral": "Personne du gouffre", - "racines": ["vuku", "tori"], + "racines": [ + "vuku", + "tori" + ], "domaine": "titre" } ] @@ -344,7 +445,10 @@ "type": "composition", "composition": "ait-a-tori", "sens_litteral": "Personne avec ancĂȘtre", - "racines": ["aita", "tori"], + "racines": [ + "aita", + "tori" + ], "domaine": "titre" } ] @@ -396,11 +500,21 @@ "type": "composition", "composition": "kot-a-tori", "sens_litteral": "Personne d'union", - "racines": ["kota", "tori"], + "racines": [ + "kota", + "tori" + ], "domaine": "famille" } ], - "synonymes_fr": ["Ă©pouse"] + "synonymes_fr": [ + "Ă©pouse", + "Ă©pouses", + "mari", + "maris", + "conjoint", + "conjoints" + ] } } } diff --git a/ancien-confluent/lexique/19-sante-dangers.json b/ancien-confluent/lexique/19-sante-dangers.json index 03253b6..73a4e6f 100644 --- a/ancien-confluent/lexique/19-sante-dangers.json +++ b/ancien-confluent/lexique/19-sante-dangers.json @@ -9,7 +9,10 @@ "type": "composition", "composition": "os-i-sanu", "sens_litteral": "Mort du corps", - "racines": ["osi", "sanu"], + "racines": [ + "osi", + "sanu" + ], "domaine": "sante", "note": "Concept de maladie comme mort partielle" } @@ -18,11 +21,15 @@ "Maladie des Antres": { "traductions": [ { - "confluent": "Osiusanuuvuku", + "confluent": "osiusanuuvuku", "type": "nom_propre", "composition": "os-i-sanu-vuku", "sens_litteral": "Maladie du gouffre", - "racines": ["osi", "sanu", "vuku"], + "racines": [ + "osi", + "sanu", + "vuku" + ], "categorie": "maladie", "note": "Maladie pulmonaire des mineurs" } @@ -35,7 +42,10 @@ "type": "composition", "composition": "ven-u-zoka", "sens_litteral": "Air de l'ennemi", - "racines": ["vena", "zoka"], + "racines": [ + "vena", + "zoka" + ], "domaine": "danger" } ] @@ -47,7 +57,11 @@ "type": "composition", "composition": "ven-u-zoka-sanu", "sens_litteral": "Air ennemi du corps", - "racines": ["vena", "zoka", "sanu"], + "racines": [ + "vena", + "zoka", + "sanu" + ], "domaine": "maladie" } ] @@ -59,7 +73,10 @@ "type": "composition", "composition": "zo-muta", "sens_litteral": "Sans manger", - "racines": ["zo", "muta"], + "racines": [ + "zo", + "muta" + ], "domaine": "maladie" } ] @@ -71,7 +88,10 @@ "type": "composition", "composition": "zo-vena", "sens_litteral": "Sans air", - "racines": ["zo", "vena"], + "racines": [ + "zo", + "vena" + ], "domaine": "danger" } ] @@ -83,7 +103,10 @@ "type": "composition", "composition": "san-u-suki", "sens_litteral": "Corps de feu", - "racines": ["sanu", "suki"], + "racines": [ + "sanu", + "suki" + ], "domaine": "maladie" } ] @@ -95,7 +118,10 @@ "type": "composition", "composition": "san-u-zoka", "sens_litteral": "Corps de l'ennemi", - "racines": ["sanu", "zoka"], + "racines": [ + "sanu", + "zoka" + ], "domaine": "sante" } ] @@ -107,7 +133,10 @@ "type": "composition", "composition": "tos-a-sanu", "sens_litteral": "Bien avec corps", - "racines": ["tosa", "sanu"], + "racines": [ + "tosa", + "sanu" + ], "domaine": "sante" } ] @@ -119,7 +148,10 @@ "type": "composition", "composition": "kar-oa-vuku", "sens_litteral": "Pierre vers le gouffre", - "racines": ["kari", "vuku"], + "racines": [ + "kari", + "vuku" + ], "domaine": "danger" } ] @@ -131,7 +163,10 @@ "type": "composition", "composition": "ur-a-eka", "sens_litteral": "Eau avec totalitĂ©", - "racines": ["ura", "eka"], + "racines": [ + "ura", + "eka" + ], "domaine": "danger" } ] @@ -173,7 +208,10 @@ "type": "composition", "composition": "vuk-u-kari", "sens_litteral": "Gouffre de pierre", - "racines": ["vuku", "kari"], + "racines": [ + "vuku", + "kari" + ], "domaine": "danger" } ] @@ -185,7 +223,10 @@ "type": "composition", "composition": "kar-i-oki", "sens_litteral": "Pierre de l'Ă©preuve", - "racines": ["kari", "oki"], + "racines": [ + "kari", + "oki" + ], "domaine": "danger" } ] @@ -197,7 +238,10 @@ "type": "composition", "composition": "nis-oa-vuku", "sens_litteral": "Neige vers le gouffre", - "racines": ["nisa", "vuku"], + "racines": [ + "nisa", + "vuku" + ], "domaine": "danger" } ] @@ -209,7 +253,10 @@ "type": "composition", "composition": "suk-i-zoka", "sens_litteral": "Feu de l'ennemi", - "racines": ["suki", "zoka"], + "racines": [ + "suki", + "zoka" + ], "domaine": "danger" } ] diff --git a/ancien-confluent/lexique/20-objets-materiaux.json b/ancien-confluent/lexique/20-objets-materiaux.json index 8927f74..a305a22 100644 --- a/ancien-confluent/lexique/20-objets-materiaux.json +++ b/ancien-confluent/lexique/20-objets-materiaux.json @@ -374,6 +374,18 @@ "domaine": "objet_rituel" } ] + }, + "maison": { + "traductions": [ + { + "confluent": "buka", + "type": "racine", + "forme_liee": "buk", + "domaine": "structure", + "note": "Habitation, foyer domestique" + } + ], + "synonymes_fr": ["habitation", "demeure", "logis"] } } } diff --git a/ancien-confluent/lexique/lowercase-confluent.js b/ancien-confluent/lexique/lowercase-confluent.js new file mode 100644 index 0000000..f0fd3c3 --- /dev/null +++ b/ancien-confluent/lexique/lowercase-confluent.js @@ -0,0 +1,67 @@ +#!/usr/bin/env node + +/** + * Script pour convertir tous les mots Confluent en minuscules dans les lexiques + * Le Confluent n'a pas de distinction majuscule/minuscule + */ + +const fs = require('fs'); +const path = require('path'); + +const LEXIQUE_DIR = __dirname; + +function lowercaseConfluentInFile(filePath) { + console.log(`Processing: ${path.basename(filePath)}`); + + const content = fs.readFileSync(filePath, 'utf-8'); + const data = JSON.parse(content); + + let changeCount = 0; + + // Parcourir le dictionnaire + if (data.dictionnaire) { + for (const [key, entry] of Object.entries(data.dictionnaire)) { + if (entry.traductions) { + entry.traductions.forEach(trad => { + if (trad.confluent && trad.confluent !== trad.confluent.toLowerCase()) { + console.log(` - ${trad.confluent} → ${trad.confluent.toLowerCase()}`); + trad.confluent = trad.confluent.toLowerCase(); + changeCount++; + } + }); + } + } + } + + // Sauvegarder si des changements ont Ă©tĂ© faits + if (changeCount > 0) { + fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8'); + console.log(` ✓ ${changeCount} changements sauvegardĂ©s\n`); + } else { + console.log(` ✓ Aucun changement nĂ©cessaire\n`); + } + + return changeCount; +} + +function main() { + console.log('=== Conversion Confluent → minuscules ===\n'); + + const files = fs.readdirSync(LEXIQUE_DIR) + .filter(f => f.endsWith('.json') && !f.startsWith('_')) + .map(f => path.join(LEXIQUE_DIR, f)); + + let totalChanges = 0; + + for (const file of files) { + try { + totalChanges += lowercaseConfluentInFile(file); + } catch (error) { + console.error(`Erreur dans ${path.basename(file)}: ${error.message}\n`); + } + } + + console.log(`=== TerminĂ©: ${totalChanges} conversions au total ===`); +} + +main();