v0.2.0 - Alpha

L'attention est tout ce dont dispose un modèle.
La concentration est ce que niuma_code apporte.

En 2017, « Attention is All You Need » a défini une époque — toute l'intelligence des modèles est bâtie sur l'attention. 8 ans plus tard, nous réalisons que le modèle ne manque pas de mécanismes d'attention — il manque de placer l'attention là où elle compte. Plus le contexte est long, plus le bruit noie les informations véritablement importantes. niuma_code fait une seule chose : tirer le contexte, ajouter la concentration — pour que chaque jeton atterrit exactement là où il doit être.

🔒
Exécution locale
Les données ne quittent jamais votre machine — confidentialité totale
🛡️
Confidentialité d'abord
Clé API stockée localement, les données de conversation ne sont jamais uploadées
📦
v0.2.0 Alpha
Amélioration continue, guidée par la communauté
💬
Support communautaire
GitHub Issues — contactez directement les développeurs

Voir le fonctionnement réel

Enregistrement d'écran réel du mode orchestration EDI — testez la concentration de niuma_code en 1 minute

Pourquoi choisir niuma_code

Pas un remplacement de Claude Code, mais un outil complémentaire pour renforcer la concentration

⚙️

Mode harness autonome

Mode par défaut — aucune commande nécessaire. Le LLM explore de manière autonome dans une boucle d'outils, réfléchit en agissant et continue tant que la tâche n'est pas terminée.

  • Boucle tool-use : le LLM détermine de manière autonome la lecture de fichiers / l'édition de code / l'exécution de commandes
  • Réessai automatique en cas d'erreur API, rendu en streaming + annulation ESC + compression automatique des sorties longues
  • Idéal pour les tâches ambiguës et difficiles à décomposer — le LLM détermine quand c'est terminé
🔁

Orchestration loop

Avec /loop <objectif>, entrez dans une boucle autonome orientée objectif : planifiez avec des commandes de vérification, exécutez séquentiellement, vérifiez chaque étape, et corrigez automatiquement en cas d'échec.

  • Plan → Exécution → Vérification → Réessai en cas d'échec (jusqu'à 3 fois, avec retour du motif d'échec)
  • Double porte orthogonale : MAX_ROUNDS=20 limite de tâches + MAX_RETRIES=3 correction automatique
  • Chaque tour appelle harness pour exécuter une étape — idéal pour les tâches d'ingénierie décomposables et vérifiables
🖥️

Mode plein écran TUI

Basé sur l'interface plein écran de prompt_toolkit. L'entrée est toujours fixée en bas ; vous pouvez ajouter de nouveaux messages à tout moment pendant le streaming LLM — le contenu n'est jamais poussé hors de l'écran.

  • 5 overlays modaux : paramètres du modèle, file d'attente de messages, changement de contexte, gestion des conversations, confirmation des permissions
  • Sélection par glisser-déposer de la souris, défilement, copie automatique au clic gauche, zoom de police Ctrl+molette
  • Barre d'état en temps réel : aperçu de la réflexion, nombre de jetons entrée/sortie, progression de la compression + annulation ESC
💻

Mode orchestration EDI

Éditeur de code plein écran. Écrivez des scripts d'orchestration en syntaxe Python native et intégrez les appels LLM dans des flux de travail scriptables et contrôlables.

  • Injection des fonctions llm_call / llm_confirm / llm_judge pour une orchestration LLM contrôlable
  • Aperçu F5 (analyse statique AST), exécution F6 (sans intervention, permissions d'outils accordées automatiquement)
  • Exécution en bac à sable sécurisé + liste noire des imports dangereux (os/subprocess/socket, etc.) — seul filet de sécurité en mode sans intervention
🔌

Acheminement multi-fournisseurs

Configurez plusieurs points de terminaison API dans settings.json — les requêtes sont automatiquement acheminées vers le bon fournisseur en fonction du nom du modèle, avec changement libre en cours de session.

  • Chaque fournisseur déclare base_url / api_key / liste des modèles supportés
  • Changement de modèle via #tag ou /model — les requêtes se connectent automatiquement au bon point de terminaison
  • Cascade de configuration à 3 niveaux (utilisateur / projet / projet local), le dernier défini prend le dessus
🗂️

Gestion parallèle du contexte

Étendez une seule conversation en N contextes parallèles, chacun gérant indépendamment son historique, son nombre de jetons et son état de compression — zéro contamination croisée.

  • Éviction LRU, limite par défaut à 5 (configurable via max_contexts) — éviction = archivé et restaurable
  • Changement via overlay visuel /context ; génération de résumé asynchrone à la sortie
  • Sélection multiple par unité via /messages — suppression / réordonnancement / intégration de résumé LLM
🕸️

Graphe de connaissances du code

Analysez la structure du code avec tree-sitter, construisez les définitions de symboles, les chaînes d'appels et les graphes de dépendances — localisez précisément les positions avant même que le LLM ne lise les lignes.

  • 4 outils de requête en lecture seule : recherche de symboles, dépendances de fichiers, références, chaînes d'appels
  • Renvoie fichier:numéro de ligne et signature — remplace l'approche « aiguille dans une botte de foin » de grep
  • Détection à 3 niveaux pour rebuild à la demande — évite l'analyse complète au démarrage
🤖

Recherche parallèle par sous-agents

Des sous-agents en lecture seule exécutent des outils en parallèle, investiguent dans des contextes isolés et ne renvoient que les résumés — le contexte principal reste propre.

  • Plusieurs sous-agents exécutent des outils en lecture seule en parallèle, de manière non bloquante
  • Investigation dans un contexte isolé, résumés uniquement — ne pollue pas la conversation principale
  • Appartient au paradigme harness par défaut, appelé à la demande plutôt qu'en mode autonome
🧠

Mémoire guidée par la perception

Mémoire persistante via memory-palace — les événements en cours d'exécution sont capturés en temps réel comme souvenirs, accumulant l'expérience entre les sessions.

  • 10 types d'événements de perception (visuel/physique/langue/nez/résultats, etc.), écriture en temps réel plutôt qu'après la conversation
  • Triplets de faits + résumé de conversation, récupération à 4 niveaux + décroissance bayésienne
  • Injection automatique dans le prompt système lors de la prochaine session, position de récupération stable
🎯

Suivi des récompenses d'outcome

Suivez le cycle de vie complet des objectifs de tâche, calculez un score de récompense basé sur la qualité d'achèvement et écrivez-le en tant qu'événement de perception dans la mémoire.

  • OutcomeTracker calcule un score de récompense de 0.0 à 1.0 pour tout le cycle de vie des tâches
  • Le score de récompense devient un signal d'évaluation de la valeur de réutilisation de la mémoire
  • Intégré en tant que l'un des 10 types d'événements de perception, avec les événements read/write/tool-call

Comment exploiter efficacement les deux modes

Si les étapes ne sont pas claires, décrivez et itérez (harness). Si vous avez une checklist, utilisez /loop

🧭

Points clés du harness

Le harness n'a pas de boucle de re-planification — plus l'entrée est claire, plus l'exploration autonome est précise.

Cas d'utilisation : vous avez une idée générale mais ne pouvez pas formuler clairement les étapes, et souhaitez avancer en itérant. Ex. : « Trouvez et corrigez l'erreur de la page de connexion »
  • Écrivez les contraintes à l'avance : objectif + fichiers/fonctions à ne pas toucher + critères d'acceptation — ne modifiez pas les exigences pendant l'exécution
  • Idéal quand les limites sont floues mais l'objectif est clair ; plus les étapes sont claires, plus la convergence est rapide
  • Utilisez les points de contrôle : ESC pour arrêter à tout moment, les sorties longues sont compressées automatiquement, les erreurs API sont retentées automatiquement
  • « Terminé » et « réellement terminé » sont deux choses différentes — après les changements importants, effectuez vos propres tests/compilations
🎯

Points clés du loop

La correction automatique repose entièrement sur la « vérification » — seuls les objectifs vérifiables donnent un sens aux 3 tentatives de correction.

Cas d'utilisation : vous pouvez décomposer la tâche en étapes, et chaque étape a un moyen de vérification correct/incorrect. Ex. : « /loop Ajoutez la pagination à l'API utilisateur et exécutez py_compile après les modifications »
  • L'objectif doit pouvoir être décomposé en étapes avec commandes de vérification — « rendez plus élégant » n'est pas vérifiable
  • Décrivez la méthode de vérification directement dans l'objectif (py_compile / tests) pour une précision de plan maximale
  • 3 échecs de correction signifient généralement un manque d'information de vérification — plutôt que d'insister, décomposez davantage
  • 3 échecs n'arrêtent pas — c'est enregistré et la boucle continue ; vérifiez les marqueurs [!!] dans le résumé

Démarrez en 3 étapes

Téléchargement, configuration, lancement — prêt en quelques secondes

01 Téléchargement
⬇ Télécharger niuma.exe
Windows · Aucune installation · Exécutable directement
02 Configuration
# ~/.niuma/settings.json
{
  "factories": [{
    "api_key": "your-key"
  }]
}
03 Lancement
$ niuma.exe
niuma_code v0.2.0 launched

Liste des paramètres de settings.json

Chemin du fichier de configuration : ~/.niuma/settings.json

factoriesConfiguration multi-fournisseurs API. Chaque fournisseur déclare base_url / api_key / liste des modèles supportés ; les requêtes sont acheminées automatiquement par nom de modèle
💡 Exemple de configuration
{
  "factories": [
    {
      "base_url": "https://api.anthropic.com",  // Anthropic official endpoint
      "api_key": "sk-ant-xxx",                   // Required; all three fields must be present
      "options": ["claude-sonnet-4-6", "claude-opus-4-8"]  // Supported models for this provider
    },
    {
      "base_url": "https://your-proxy.example.com",  // Anthropic-compatible proxy endpoint
      "api_key": "sk-proxy-xxx",
      "options": ["claude-sonnet-4-6"]  // Supported models for this endpoint
    }
  ]
}
Paramètre Type Défaut Description
base_url string --- URL du point de terminaison API (requis)
api_key string --- Clé API (requis)
options string[] [] Noms des modèles supportés par ce fournisseur
llmModèle, niveau d'effort, budget de réflexion et gestion du contexte
💡 Exemple de configuration
{
  "llm": {
    "default_model": "claude-sonnet-4-6",   // Default value for /model switch
    "default_effort": "high",               // Determines which thinking_budget is used
    "max_contexts": 5,                      // Max parallel contexts; LRU eviction beyond limit
    "resume_latest_context": true,          // Resume last active context on startup
    "options": [                            // Model -> effort mapping
      {"claude-sonnet-4-6": ["low", "medium", "high"]},
      {"claude-opus-4-8": ["low", "medium", "high", "max"]}
    ],
    "thinking_budget_low": "0",             // 0 = disable extended thinking
    "thinking_budget_medium": "0",
    "thinking_budget_high": "10000",        // Thinking budget for high effort
    "thinking_budget_max": "20000"           // Thinking budget for max effort (deepest reasoning)
  }
}
Paramètre Type Défaut Description
default_model string "claude-sonnet-4-6" Modèle par défaut (fixe pendant la session, modifiable via /model)
default_effort string "high" Niveau d'effort par défaut — contrôle la profondeur du budget de réflexion
max_contexts integer 5 Nombre maximal de contextes parallèles actifs ; éviction LRU au-delà de la limite
resume_latest_context boolean true Restaure le dernier contexte actif au démarrage ; false = démarrage propre
options object[] [] Mapping modèle → effort, utilisé pour la validation du changement via /model
thinking_budget_low string/int "0" Budget de jetons de réflexion pour l'effort low (0 = désactivé)
thinking_budget_medium string/int "0" Budget de jetons de réflexion pour l'effort medium
thinking_budget_high string/int "10000" Budget de jetons de réflexion pour l'effort high
thinking_budget_max string/int "20000" Budget de jetons de réflexion pour l'effort max (raisonnement le plus profond)
envVariables d'environnement écrites dans os.environ. Contrôle de la personnalité, du débogage, du réseau et du comportement des permissions
💡 Exemple de configuration
{
  "env": {
    "PERSONA_NAME": "niuma",              // AI persona name, injected into system prompt
    "MODEL_BACKGROUND": "claude-haiku-4-5", // Background task model (memory extraction, compression, etc.)
    "LANG": "zh",                        // UI language (zh/en); also controls LLM response language
    "TEMPERATURE_ZERO": "true",            // Note: all values are strings
    "API_TIMEOUT": "30",                   // Streaming stall timeout (seconds)
    "API_ROUND_MAX": "120",                // Per-turn wall-clock hard limit (seconds)
    "API_STALL_MAX_RETRIES": "10",        // Max auto-retries on stream stall
    "PERMISSION_MODE": "auto",             // auto=whitelist+confirm / manual=whitelist only / skip=allow all
    "ALLOWED_TOOLS": ""                    // Whitelisted tools (comma-separated); empty = built-in defaults
  }
}
Paramètre Type Défaut Description
PERSONA_NAME string "niuma" Nom de la personnalité IA, injecté dans le prompt système
MODEL_BACKGROUND string "claude-haiku-4-5" Modèle pour les tâches en arrière-plan (extraction de mémoire, compression, etc.)
LANG string "en" Langue de l'interface (zh/en) ; contrôle aussi la langue de réponse du LLM
TEMPERATURE_ZERO string(bool) "true" Fixe temperature=0 pour une sortie déterministe ; false = défaut du modèle
API_TIMEOUT string/int "30" Délai d'expiration de blocage du streaming (secondes) — reconnexion si aucun événement au-delà
API_ROUND_MAX string/int "120" Limite absolue en temps réel par tour (secondes) — force l'arrêt du flux ancien
API_STALL_MAX_RETRIES string/int "10" Nombre max de tentatives automatiques en cas de blocage du flux
PERMISSION_MODE string "auto" Mode de permission : auto (liste blanche+confirmation) / manual (liste blanche uniquement) / skip (tout autoriser)
ALLOWED_TOOLS string "" Liste blanche d'outils séparée par des virgules ; vide = valeurs intégrées par défaut
compactCompression du contexte : compressez automatiquement les conversations longues tout en conservant les informations importantes
💡 Exemple de configuration
{
  "compact": {
    // -- Inline compression (blocks main loop until done) --
    "inline_trigger": 0.8,      // Triggers at 80% of MAX_TOKENS
    "inline_keep_ratio": 0.4,   // Keep latest 40% of messages after compression

    // -- Post-reply async compression (non-blocking, runs in background) --
    "idle_trigger": 0.5,        // Triggers at 50% of MAX_TOKENS
    "idle_keep_ratio": 0.4,     // Keep latest 40% of messages after compression

    // -- LLM summary output limit --
    "max_summary_tokens": 4096  // Max tokens for generated summary
  }
}
Paramètre Type Défaut Description
inline_trigger float 0.8 Taux de déclenchement de la compression inline — bloque la boucle principale lorsqu'atteint
inline_keep_ratio float 0.4 Proportion des messages récents à conserver après la compression inline
idle_trigger float 0.5 Taux de déclenchement de la compression au repos — exécuté en arrière-plan après la réponse
idle_keep_ratio float 0.4 Proportion des messages récents à conserver après la compression au repos
max_summary_tokens integer 4096 Nombre max de jetons pour le résumé généré par le LLM
memory_palaceConfiguration LLM de Memory Palace ; indépendante du bloc llm, parsée séparément
💡 Exemple de configuration
// Basic mode: rule-based extraction only (no LLM, zero cost)
{
  "memory_palace": {
    "enable_v9": false,        // Disable V9; falls back to legacy V8 mode
    "llm_enabled": false        // Disable LLM enhancement
  }
}

// Full mode: LLM-enhanced extraction (all three fields required; otherwise falls back to rule-based)
{
  "memory_palace": {
    "enable_v9": true,
    "llm_enabled": true,       // Once enabled, the following three fields are required
    "base_url": "https://api.anthropic.com",
    "api_key": "sk-ant-xxx",
    "model": "claude-haiku-4-5"    // Recommend a lightweight model to save tokens
  }
}
Paramètre Type Défaut Description
enable_v9 boolean true Active la mémoire guidée par la perception V9 ; false = mode legacy V8
llm_enabled boolean false Active l'extraction de mémoire améliorée par LLM ; false = règles uniquement
base_url string "" Point de terminaison API du LLM pour la mémoire (les 3 champs sont requis, sinon fallback sur les règles)
api_key string "" Clé API du LLM pour la mémoire
model string "" Modèle du LLM pour la mémoire (modèle léger recommandé pour économiser des jetons)
memory_qualitySeuils de qualité de la mémoire ; contrôlent le filtrage à l'écriture et la précision de la récupération
💡 Exemple de configuration
{
  "memory_quality": {
    "min_store_importance": 0.4,  // Write gate: discard facts with importance below this threshold
    "min_recall_score": 0.35,     // Recall gate: skip memories scoring below this threshold
    "dedup_threshold": 0.3        // Dedup threshold: Jaccard similarity above this = duplicate
  }
}
Paramètre Type Défaut Description
min_store_importance float 0.4 Porte d'écriture : abandonne les faits dont l'importance est inférieure à ce seuil lors de l'extraction
min_recall_score float 0.35 Porte de récupération : ignore les souvenirs dont le score est inférieur à ce seuil, non injectés dans le prompt
dedup_threshold float 0.3 Seuil de dédoublonnage : similarité Jaccard supérieure à cette valeur = doublon, conserve la version la plus récente

Liste des commandes disponibles

Exécutez des actions rapides avec les commandes slash

Commande Description
/ide Lance l'éditeur de code plein écran
/context Gestion multi-contexte (nouveau/renommer/changer/supprimer)
/help Affiche les informations d'aide
/copy Copie la dernière réponse dans le presse-papiers
/resume Reprend les tâches inachevées
/clear Efface le contexte de conversation
/restart Redémarre niuma
/model Vérifie/change le modèle
/quit Quitte le programme

Commandes rapides #tag

Utilisez #tag pour injecter rapidement des instructions prédéfinies — définissez une fois, réutilisez à l'infini

💡

Qu'est-ce qu'un #tag

Les étiquettes personnalisées sont des raccourcis définis par l'utilisateur qui se développent en texte prédéfini lorsque vous tapez #nomtag.

  • Taper #fr se développe automatiquement en « réponds en français »
  • Supporte les étiquettes personnalisées arbitraires, insensible à la casse
  • Les étiquettes peuvent être placées n'importe où dans l'entrée, supprimées automatiquement après l'analyse
  • Le texte développé est ajouté à l'entrée pour que le LLM puisse le comprendre
Exemple : #fr Pensez à la complexité du tri à bulles
⚙️

Deux types d'étiquettes

Les étiquettes système contrôlent le mode de fonctionnement, les étiquettes personnalisées injectent des instructions prédéfinies. Elles se complètent.

  • #plan_mode — force l'analyse uniquement, pas d'exécution (priorité maximale)
  • #skip_mode — ignore toutes les permissions, exécute les outils directement
  • #custom — raccourci défini par l'utilisateur
  • Si plan_mode et skip_mode sont entrées en même temps, plan_mode a la priorité
📋

Gestion des commandes /tag

Utilisez la commande /tag pour ajouter, modifier, supprimer ou lister les étiquettes personnalisées.

  • /tag — ouvre le panneau de gestion des étiquettes (TUI) ou affiche la liste (CLI)
  • /tag add <nom> <texte> — ajoute une nouvelle étiquette
  • /tag mod <nom> <texte> — modifie une étiquette existante
  • /tag rm <nom> — supprime une étiquette
  • /tag ls — liste toutes les étiquettes
🎯

Cas d'utilisation courants

Encapsulez les instructions fréquentes sous forme d'étiquettes pour améliorer l'efficacité de la conversation.

  • #fr — force la réponse en français
  • #fix — instruction standard de correction de bug
  • #review — exigences standard de revue de code
  • #explain — explication détaillée de la logique du code
Utilisation combinée : #plan_mode #fr Analysez les goulots d'étranglement de performance de cette fonction
💾

Emplacement de stockage et configuration

Les étiquettes sont sauvegardées dans un fichier JSON, au même emplacement que settings.json.

  • Emplacement : ~/.niuma/custom_tags.json
  • Format clé-valeur simple, les clés sont automatiquement converties en minuscules
  • Écriture atomique, compatible Windows
Exemple de fichier :
{
  "fr": "Réponds en français",
  "fix": "Corrige le bug"
}
🔄

Pipeline d'analyse

L'entrée passe par un routage à 3 voies, garantissant que la compréhension du LLM, la récupération de mémoire et la sauvegarde de perception disposent chacune des informations nécessaires.

  • raw_input — entrée originale, pour la sauvegarde de trace
  • llm_input — entrée après développement des étiquettes, pour la compréhension du LLM
  • filter_input — entrée sans étiquettes, pour la récupération de mémoire
  • La mémoire n'est pas polluée par les étiquettes, la récupération reste précise