Phase 1.2 : productivite de creation

Construire une grande carte demande beaucoup moins de gestes.

Ordre des freres (format v3)
`MindMapNode.order` devient la position parmi les freres. `parentId` reste la
seule source de verite de la relation hierarchique : une source par
preoccupation, jamais deux versions contradictoires. L'ordre est renumerote a
chaque modification structurelle dans `withEdges`, unique point de passage.
Le format passe en v3 : un lecteur v2 ignorerait `order` et reordonnerait
silencieusement la carte. Migration v2 -> v3 depuis la position dans le tableau,
v1 -> v2 -> v3 s'enchainent, et les noeuds sont ecrits en parcours de profondeur
pour rester corrects meme pour un lecteur anterieur.

Creation rapide
- Ajouter plusieurs enfants : une ligne = un noeud, avec apercu avant creation.
- Collage d'une liste multi-ligne sur un noeud : le presse-papiers interne reste
  prioritaire, l'edition de texte n'est jamais interceptee.
- Import d'une arborescence indentee : espaces ou tabulations, puces retirees,
  indentation incoherente signalee avec le numero de ligne plutot que devinee.
- Les nouveaux noeuds sont repartis autour du parent au lieu de se superposer.

Hierarchie
Monter, descendre, placer en premier ou en dernier, remonter d'un niveau,
"Deplacer vers..." avec recherche, suppression d'un noeud en conservant ses
enfants a la place qu'il occupait. Le re-parentage passe toujours par
`reparentNode` : la detection de cycle n'est ecrite qu'une fois.

Branches
Selectionner, dupliquer, copier, coller comme enfant, deplacer avec ses
descendants (reglage, ou Alt pour l'inverser le temps d'un glisser), replier et
developper une branche, tout replier, tout developper, replier au-dela d'un
niveau.

Clavier
Maj+Tab remonte d'un niveau, Maj+Entree ouvre la creation multiple, Alt+Haut et
Alt+Bas reordonnent. Tab, Entree et F2 gardent leur comportement.

Historique
Chaque operation logique reste une seule entree : creation multiple, import
d'outline, reordonnancement, deplacement de branche, duplication, collage,
suppression, tout replier.

Tests : 172 vitest (103 -> 172) et 36 pytest (31 -> 36).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

frontend/src/services/outlineParser.ts

@@ -0,0 +1,173 @@
+import { APP_CONFIG } from '@/config/app';
+
+/**
+ * Lecture d'une arborescence indentee collee par l'utilisateur.
+ *
+ * Volontairement limite a un "outline" : une ligne = un noeud, l'indentation
+ * donne la profondeur. Ce n'est pas un lecteur Markdown ; seules les puces de
+ * liste les plus courantes sont retirees pour que coller une liste a puces
+ * fonctionne sans retouche.
+ */
+
+export interface OutlineNode {
+  text: string;
+  children: OutlineNode[];
+}
+
+export interface OutlineResult {
+  roots: OutlineNode[];
+  /** Nombre total de noeuds, tous niveaux confondus. */
+  count: number;
+  /** Profondeur maximale, la racine comptant pour 1. */
+  depth: number;
+}
+
+/** Erreur d'analyse, deja formulee pour l'utilisateur. */
+export class OutlineError extends Error {
+  readonly line: number;
+
+  constructor(message: string, line: number) {
+    super(message);
+    this.name = 'OutlineError';
+    this.line = line;
+  }
+}
+
+const TAB_WIDTH = 4;
+const MAX_DEPTH = 20;
+const MAX_TEXT_LENGTH = 500;
+const BULLET = /^[-*+\u2022\u25E6\u2023]\s+/;
+const NUMBERED = /^\d{1,3}[.)]\s+/;
+
+function indentWidth(line: string): number {
+  let width = 0;
+  for (const character of line) {
+    if (character === ' ') width += 1;
+    else if (character === '\t') width += TAB_WIDTH;
+    else break;
+  }
+  return width;
+}
+
+function cleanText(line: string): string {
+  return line.trim().replace(BULLET, '').replace(NUMBERED, '').trim().slice(0, MAX_TEXT_LENGTH);
+}
+
+/**
+ * Analyse un texte indente.
+ *
+ * Une indentation incoherente (un niveau qui ne correspond a aucun niveau
+ * ouvert) est signalee plutot que devinee : mieux vaut un message clair qu'une
+ * hierarchie absurde.
+ */
+export function parseOutline(text: string, maxNodes: number = APP_CONFIG.maxNodes): OutlineResult {
+  const rawLines = text.replace(/\r\n?/g, '\n').split('\n');
+
+  const entries: Array<{ indent: number; text: string; line: number }> = [];
+  rawLines.forEach((raw, index) => {
+    if (raw.trim().length === 0) return; // les lignes vides sont ignorees
+    const content = cleanText(raw);
+    if (content.length === 0) return;
+    entries.push({ indent: indentWidth(raw), text: content, line: index + 1 });
+  });
+
+  if (entries.length === 0) {
+    throw new OutlineError('Aucune ligne exploitable dans le texte fourni.', 0);
+  }
+  if (entries.length > maxNodes) {
+    throw new OutlineError(
+      `Ce texte produirait ${entries.length} noeuds : la limite est de ${maxNodes}.`,
+      0,
+    );
+  }
+
+  const base = entries[0]?.indent ?? 0;
+  const roots: OutlineNode[] = [];
+  // Pile des niveaux ouverts : largeur d'indentation -> noeud parent.
+  const stack: Array<{ indent: number; node: OutlineNode | null }> = [{ indent: base, node: null }];
+
+  for (const entry of entries) {
+    if (entry.indent < base) {
+      throw new OutlineError(
+        `Ligne ${entry.line} : elle est moins indentee que la premiere ligne.`,
+        entry.line,
+      );
+    }
+
+    // On referme les niveaux plus profonds que la ligne courante.
+    let closedLevels = false;
+    while (
+      stack.length > 1 &&
+      entry.indent < (stack[stack.length - 1] as { indent: number }).indent
+    ) {
+      stack.pop();
+      closedLevels = true;
+    }
+
+    const top = stack[stack.length - 1] as { indent: number; node: OutlineNode | null };
+    const node: OutlineNode = { text: entry.text, children: [] };
+
+    if (entry.indent === top.indent) {
+      const parent =
+        stack.length > 1 ? (stack[stack.length - 2] as { node: OutlineNode | null }).node : null;
+      if (parent) parent.children.push(node);
+      else roots.push(node);
+      stack[stack.length - 1] = { indent: entry.indent, node };
+      continue;
+    }
+
+    /*
+     * Ici l'indentation est superieure au niveau courant. Si l'on vient de
+     * refermer des niveaux, c'est qu'elle ne correspond a aucun niveau ouvert :
+     * l'outline est incoherent, on le signale plutot que de deviner.
+     */
+    if (closedLevels) {
+      throw new OutlineError(
+        `Ligne ${entry.line} : indentation incoherente avec les lignes precedentes.`,
+        entry.line,
+      );
+    }
+    if (!top.node) {
+      throw new OutlineError(
+        `Ligne ${entry.line} : indentation inattendue, aucun element parent au-dessus.`,
+        entry.line,
+      );
+    }
+    if (stack.length >= MAX_DEPTH) {
+      throw new OutlineError(
+        `Ligne ${entry.line} : arborescence trop profonde (maximum ${MAX_DEPTH} niveaux).`,
+        entry.line,
+      );
+    }
+
+    top.node.children.push(node);
+    stack.push({ indent: entry.indent, node });
+  }
+
+  return { roots, count: entries.length, depth: measureDepth(roots) };
+}
+
+function measureDepth(nodes: OutlineNode[]): number {
+  let deepest = 0;
+  for (const node of nodes) {
+    deepest = Math.max(deepest, 1 + measureDepth(node.children));
+  }
+  return deepest;
+}
+
+/** Vrai si le texte contient au moins une indentation exploitable. */
+export function looksIndented(text: string): boolean {
+  return text
+    .replace(/\r\n?/g, '\n')
+    .split('\n')
+    .some((line) => line.trim().length > 0 && /^[ \t]+/.test(line));
+}
+
+/** Lignes non vides d'un texte, sans puce ni numerotation. */
+export function toFlatLines(text: string): string[] {
+  return text
+    .replace(/\r\n?/g, '\n')
+    .split('\n')
+    .map(cleanText)
+    .filter((line) => line.length > 0);
+}