action_parser.py

#!/usr/bin/env python3
"""
Multi-level robust tool call parser for NEMESIS CLI.

Parsing strategy (6 niveaux, tries in order):
  1. YAML-style named code fences : ```tool_name\\nkey: value\\n```
  2. Strict JSON in code fence   : ```json\\n{ "tool": "...", ... }\\n```
  3. Relaxed JSON (repaired)     : same, but auto-fixes common LLM errors
  4. JSON inline (sans fence)    :  ```...\\n{ "tool": ..., ... }\\n```
  5. XML-style action tags       : <ACTION type="...">...</ACTION>
  6. Regex fallback              : détection par motifs textuels

Avantages par rapport à l'ancien système (``_parse_tool_json``) :
- Le format YAML gère naturellement le contenu multi-lignes (``content: |``)
- Les guillemets et apostrophes dans le contenu ne cassent plus le parsing
- La détection XML couvre l'ancien format de l'agent
- Les réparations JSON progressives sont plus agressives
"""

import re
import json
from typing import Dict, Any, Optional, List, Tuple, Set


class ActionParser:
    """Parseur multi-niveaux d'appels d'outils."""

    # Outils valides — synchronisé avec VALID_TOOLS dans agent.py
    VALID_TOOLS: Set[str] = {
        "read_file", "search_replace", "write_file", "bash",
        "get_task_output", "kill_task", "list_dir", "grep",
        "web_search", "web_fetch", "delete_file",
        "mcp_list", "mcp_tools_list", "mcp_call",
        # Anciens noms (legacy tools_schema.py)
        "write", "read", "replace", "append",
        "validate", "status", "kill_process", "stop_all",
        "cleanup_logs", "list_agents", "delegate_task",
        "check_reports", "update_tracker", "skills_list",
    }

    # Mapping anciens noms -> nouveaux noms
    LEGACY_MAP: Dict[str, str] = {
        "write": "write_file",
        "read": "read_file",
        "replace": "search_replace",
    }

    def __init__(self, extra_valid_tools: Optional[Set[str]] = None):
        if extra_valid_tools:
            self.VALID_TOOLS = self.VALID_TOOLS | extra_valid_tools

    # ------------------------------------------------------------------
    # Point d'entrée principal
    # ------------------------------------------------------------------

    def parse(self, raw_response: str) -> Dict[str, Any]:
        """Parse une réponse brute du LLM et extrait l'outil éventuel.

        Retourne:
            {'text': str, 'action': None|{'type': str, 'content': dict}}
        """
        result: Dict[str, Any] = {'text': raw_response or '', 'action': None}

        if not raw_response or not isinstance(raw_response, str):
            return result

        if raw_response.startswith("FEEDBACK:"):
            result['text'] = raw_response
            return result

        # --- Level 1: YAML-style named code fence ---
        action = self._parse_yaml_fence(raw_response)
        if action:
            return self._split_text_and_action(raw_response, action, r'```\w*\n.*?\n```', re.S)

        # --- Level 2: JSON strict in code fence ---
        action = self._parse_json_fence(raw_response, strict=True)
        if action:
            return self._split_text_and_action(raw_response, action, r'```(?:json|JSON)?\s*\n.*?\n?\s*```', re.S)

        # --- Level 3: JSON relaxed (repaired) ---
        action = self._parse_json_fence(raw_response, strict=False)
        if action:
            return self._split_text_and_action(raw_response, action, r'```(?:json|JSON)?\s*\n.*?\n?\s*```', re.S)

        # --- Level 4: JSON inline sans fence (```{...}```) ---
        action = self._parse_bare_code_block(raw_response)
        if action:
            return self._split_text_and_action(raw_response, action, r'```\s*\n?\{.*?\}\n?\s*```', re.S)

        # --- Level 5: XML-style action tags ---
        action = self._parse_xml_action(raw_response)
        if action:
            text = re.sub(r'<ACTION[^>]*>.*?</ACTION>', '', raw_response, flags=re.S).strip()
            result['text'] = text or ""
            result['action'] = action
            return result

        # --- Level 6: Regex fallback ---
        action = self._parse_text_fallback(raw_response)
        if action:
            result['action'] = action
            return result

        # Aucune action detectée
        if not result['text']:
            result['text'] = ""
        return result

    # ------------------------------------------------------------------
    # Level 1: YAML-style named code fence
    # ------------------------------------------------------------------

    def _parse_yaml_fence(self, text: str) -> Optional[Dict[str, Any]]:
        """Détecte ```tool_name\\nclé: valeur\\n``` et extrait les paramètres.

        Supporte le bloc scalaire YAML | (literal block) pour le contenu
        multi-lignes, ce qui résout le problème d'échappement JSON.
        """
        # Patterns acceptés :
        # ```write_file       ```write
        # file_path: test.py  path: test.py
        # content: |          content: |
        #   line1               line1
        #   line2               line2
        # ```                 ```
        pattern = re.compile(
            r'```(\w+)\s*\n'           # ouverture ```tool_name
            r'(.*?)'                    # paramètres (non greedy)
            r'\n\s*```'                # fermeture ```
            ,
            re.S
        )

        for match in pattern.finditer(text):
            tool_name = match.group(1).strip()
            yaml_block = match.group(2).strip()

            if tool_name not in self.VALID_TOOLS:
                continue

            params = self._parse_yaml_block(yaml_block)
            if params is not None:
                tool_name = self.LEGACY_MAP.get(tool_name, tool_name)
                return {'type': tool_name, 'content': params}

        return None

    def _parse_yaml_block(self, block: str) -> Optional[Dict[str, Any]]:
        """Parse un bloc YAML simple avec support des scalaires littéraux |.

        Format:
            key1: value1
            key2: |
              line1
              line2
            key3: value3
        """
        params: Dict[str, Any] = {}
        lines = block.split('\n')
        i = 0

        while i < len(lines):
            line = lines[i]
            if not line.strip():
                i += 1
                continue

            # Détecter une clé: valeur
            match = re.match(r'^(\w+):\s*(.*)', line)
            if not match:
                i += 1
                continue

            key = match.group(1)
            value_part = match.group(2).strip()

            # Détecter le bloc scalaire littéral |
            if value_part == '|':
                # Collecter toutes les lignes indentées qui suivent
                multiline: List[str] = []
                i += 1
                while i < len(lines) and (lines[i].startswith('  ') or lines[i].startswith('\t') or not lines[i].strip()):
                    if lines[i].strip():
                        # Enlever 2 espaces d'indentation du bloc YAML
                        stripped = lines[i][2:] if lines[i].startswith('  ') else lines[i].lstrip()
                        multiline.append(stripped)
                    else:
                        multiline.append('')
                    i += 1
                params[key] = '\n'.join(multiline)
                continue
            # Détecter le bloc scalaile > (folded)
            elif value_part == '>':
                multiline = []
                i += 1
                while i < len(lines) and (lines[i].startswith('  ') or lines[i].startswith('\t') or not lines[i].strip()):
                    if lines[i].strip():
                        stripped = lines[i][2:] if lines[i].startswith('  ') else lines[i].lstrip()
                        multiline.append(stripped)
                    else:
                        multiline.append('')
                    i += 1
                # Remplacer les nouvelles lignes par des espaces (sauf lignes vides = paragraphe)
                result = ''
                for ml in multiline:
                    if ml == '':
                        result += '\n\n'
                    else:
                        result += ml + ' '
                params[key] = result.strip()
                continue

            # Valeur simple ou liste
            if value_part.startswith('[') and value_part.endswith(']'):
                # Liste simple: [a, b, c]
                items = [x.strip().strip('"').strip("'") for x in value_part[1:-1].split(',')]
                params[key] = items
            elif value_part.lower() == 'true':
                params[key] = True
            elif value_part.lower() == 'false':
                params[key] = False
            elif value_part.isdigit():
                params[key] = int(value_part)
            else:
                # String simple — enlever les guillemets si présents
                params[key] = value_part.strip('"').strip("'")

            i += 1

        return params if params else None

    # ------------------------------------------------------------------
    # Level 2 & 3: JSON in code fence (strict + relaxed)
    # ------------------------------------------------------------------

    def _parse_json_fence(self, text: str, strict: bool = True) -> Optional[Dict[str, Any]]:
        """Détecte ```json\\n{...}\\n``` et parse le JSON."""
        # Pattern: ```json ... ``` ou ```JSON ... ``` ou ``` ... ```
        patterns = [
            r'```(?:json|JSON)\s*\n(.*?)```',
            r'```\s*\n(.*?)```',
        ]

        for pat in patterns:
            for match in re.finditer(pat, text, re.S):
                json_str = match.group(1).strip()
                if not json_str.startswith('{'):
                    continue
                action = self._parse_json(json_str, strict)
                if action:
                    return action

        return None

    def _parse_json(self, raw: str, strict: bool = True) -> Optional[Dict[str, Any]]:
        """Parse un objet JSON représentant un appel d'outil."""
        json_str = raw.strip()
        if not json_str.startswith('{') or not json_str.endswith('}'):
            return None

        if strict:
            # Tentative unique avec json.loads()
            try:
                obj = json.loads(json_str)
            except (json.JSONDecodeError, ValueError):
                return None
            return self._validate_tool_obj(obj)

        # Mode relaxé : tentatives progressives de réparation
        for attempt in range(6):
            candidate = json_str
            if attempt > 0:
                candidate = self._repair_json(json_str, attempt - 1)

            try:
                obj = json.loads(candidate)
            except (json.JSONDecodeError, ValueError):
                continue

            result = self._validate_tool_obj(obj)
            if result:
                return result

        return None

    def _repair_json(self, s: str, attempt: int) -> str:
        """Réparations progressives d'un JSON invalide produit par un LLM."""
        if attempt == 0:
            # Étape 0: newlines et tabulations dans les chaînes
            return self._fix_json_newlines(s)
        elif attempt == 1:
            # Étape 1: commentaires // et /* */, virgules traînantes
            cleaned = re.sub(r'/\*.*?\*/', '', s, flags=re.S)
            cleaned = re.sub(r'//[^\n]*', '', cleaned)
            cleaned = re.sub(r',\s*}', '}', cleaned)
            cleaned = re.sub(r',\s*]', ']', cleaned)
            return cleaned
        elif attempt == 2:
            # Étape 2: clés sans guillemets
            return re.sub(
                r'([{,]\s*)([A-Za-z_][A-Za-z0-9_]*)(\s*:)',
                r'\1"\2"\3',
                s,
            )
        elif attempt == 3:
            # Étape 3: quotes simples -> doubles quotes
            return self._fix_single_quotes(s)
        elif attempt == 4:
            # Étape 4: JSON tronqué - fermer les accolades/crochets manquants
            return self._fix_truncated_json(s)
        elif attempt == 5:
            # Étape 5: dernier recours - tenter de trouver n'importe quel JSON valide
            # en extrayant la plus grande sous-chaîne parsable
            return self._extract_largest_json(s)
        return s

    def _fix_json_newlines(self, s: str) -> str:
        """Échappe les newlines / tabulations réels à l'intérieur des chaînes JSON."""
        result = []
        in_string = False
        escape_next = False
        for ch in s:
            if escape_next:
                result.append(ch)
                escape_next = False
                continue
            if ch == '\\':
                result.append(ch)
                escape_next = True
                continue
            if ch == '"':
                in_string = not in_string
                result.append(ch)
                continue
            if in_string and ch == '\n':
                result.append('\\n')
                continue
            if in_string and ch == '\r':
                result.append('\\r')
                continue
            if in_string and ch == '\t':
                result.append('\\t')
                continue
            result.append(ch)
        return ''.join(result)

    def _fix_single_quotes(self, s: str) -> str:
        """Remplace les quotes simples par des doubles quotes dans un JSON.

        Attention: ne remplace que les quotes simples qui sont clairement
        des délimiteurs de chaîne, pas les apostrophes dans le texte.
        """
        # Stratégie: remplacer 'key': par "key": et : 'value' par : "value"
        # Utiliser des regex ciblées plutôt qu'un remplacement global
        s = re.sub(r"'\s*:", '":', s)
        s = re.sub(r":\s*'", ': "', s)
        # Gérer les virgules: 'value', -> "value",
        s = re.sub(r"'\s*,", '",', s)
        s = re.sub(r",\s*'", ', "', s)
        # Début/fin d'objet: {' -> {"  et '} -> "}
        s = re.sub(r"\{\s*'", '{"', s)
        s = re.sub(r"'\s*\}", '"}', s)
        s = re.sub(r"\[\s*'", '["', s)
        s = re.sub(r"'\s*\]", '"]', s)
        return s

    def _fix_truncated_json(self, s: str) -> str:
        """Ajoute les crochets/accolades fermants manquants."""
        depth = 0
        in_string = False
        escape_next = False
        for ch in s:
            if escape_next:
                escape_next = False
                continue
            if ch == '\\':
                escape_next = True
                continue
            if ch == '"':
                in_string = not in_string
                continue
            if in_string:
                continue
            if ch in '{[':
                depth += 1
            elif ch in '}]':
                depth -= 1
        return s + ('}' if depth > 0 else '') * max(depth, 0)

    def _extract_largest_json(self, s: str) -> str:
        """Trouve la plus grande sous-chaîne parsable comme JSON.

        Utile quand le LLM ajoute du texte après le JSON valide.
        """
        # Chercher le premier { et tout prendre jusqu'à la dernière }
        # correspondante
        start = s.find('{')
        if start < 0:
            return s

        depth = 0
        end = start
        in_string = False
        escape_next = False
        for i in range(start, len(s)):
            ch = s[i]
            if escape_next:
                escape_next = False
                continue
            if ch == '\\':
                escape_next = True
                continue
            if ch == '"':
                in_string = not in_string
                continue
            if in_string:
                continue
            if ch in '{[':
                depth += 1
            elif ch in '}]':
                depth -= 1
                if depth == 0:
                    end = i + 1
                    break

        if end > start:
            # Fermer si tronqué
            candidate = s[start:end]
            return self._fix_truncated_json(candidate)
        return s

    def _validate_tool_obj(self, obj: Any) -> Optional[Dict[str, Any]]:
        """Valide qu'un objet parsé est un appel d'outil NEMESIS valide."""
        if not isinstance(obj, dict):
            return None

        tool_name = (
            obj.get("tool")
            or obj.get("name")
            or obj.get("action")
            or ""
        )
        if not tool_name or not isinstance(tool_name, str):
            return None

        if tool_name not in self.VALID_TOOLS:
            return None

        tool_name = self.LEGACY_MAP.get(tool_name, tool_name)

        params = (
            obj.get("parameters")
            or obj.get("arguments")
            or obj.get("params")
            or {}
        )
        if not isinstance(params, dict):
            params = {"value": params}

        return {'type': tool_name, 'content': params}

    # ------------------------------------------------------------------
    # Level 4: Bare code block (```{...}```)
    # ------------------------------------------------------------------

    def _parse_bare_code_block(self, text: str) -> Optional[Dict[str, Any]]:
        """Détecte ```{...}``` sans marqueur json."""
        pattern = re.compile(r'```\s*\n?(\{.*?\})\n?\s*```', re.S)
        for match in pattern.finditer(text):
            block = match.group(1).strip()
            if block.startswith('{') and block.endswith('}'):
                action = self._parse_json(block, strict=False)
                if action:
                    return action
        return None

    # ------------------------------------------------------------------
    # Level 5: XML-style action tags
    # ------------------------------------------------------------------

    def _parse_xml_action(self, text: str) -> Optional[Dict[str, Any]]:
        """Détecte <ACTION type="tool_name">...</ACTION> (ancien format)."""
        # Format court: <ACTION type="bash">commande</ACTION>
        short = re.compile(r'<ACTION\s+type="(\w+)"\s*>\n?(.*?)\n?</ACTION>', re.S)
        for match in short.finditer(text):
            tool_name = match.group(1)
            content = match.group(2).strip()
            if tool_name not in self.VALID_TOOLS:
                continue
            tool_name = self.LEGACY_MAP.get(tool_name, tool_name)
            return {'type': tool_name, 'content': {"value": content}}

        # Format long avec paramètres nommés:
        # <ACTION type="write">
        #   <path>fichier</path>
        #   <content>contenu</content>
        # </ACTION>
        long = re.compile(
            r'<ACTION\s+type="(\w+)"\s*>\s*\n'
            r'(.*?)'
            r'\n\s*</ACTION>',
            re.S
        )
        for match in long.finditer(text):
            tool_name = match.group(1)
            inner = match.group(2)
            if tool_name not in self.VALID_TOOLS:
                continue

            # Extraire les balises <nom_param>valeur</nom_param>
            params: Dict[str, Any] = {}
            for param_match in re.finditer(r'<(\w+)>(.*?)</\1>', inner, re.S):
                param_name = param_match.group(1)
                param_value = param_match.group(2).strip()
                params[param_name] = param_value

            if params:
                tool_name = self.LEGACY_MAP.get(tool_name, tool_name)
                return {'type': tool_name, 'content': params}

        return None

    # ------------------------------------------------------------------
    # Level 6: Regex text fallback
    # ------------------------------------------------------------------

    def _parse_text_fallback(self, text: str) -> Optional[Dict[str, Any]]:
        """Dernier recours : détection par motifs textuels.

        Cherche des patterns comme :
        - "J'utilise read_file pour lire fichier.txt"
        - "Exécution de bash: ls -la"
        """
        # Pattern: "j'utilise <tool>" ou "je lance <tool>"
        patterns = [
            (r"(?:j'utilise|j'execute|je lance|je vais utiliser|j'appelle)\s+`?(\w+)`?\s*(?:pour|sur|dans|avec)?\s*(.*?)(?:\.|$)", False),
            (r"(?:utilisation|appel|execution)\s+(?:de|d'|du)\s+`?(\w+)`?\s*(.*?)(?:\.|$)", False),
            (r"`(\w+)`\s+(?:sera|va|doit|va etre)\s+(?:utilise|execute|appele)\s*(.*?)(?:\.|$)", False),
        ]

        for pat, _ in patterns:
            for match in re.finditer(pat, text, re.I):
                tool_name = match.group(1).lower()
                if tool_name in self.VALID_TOOLS:
                    tool_name = self.LEGACY_MAP.get(tool_name, tool_name)
                    extra = match.group(2).strip() if match.lastindex and match.lastindex >= 2 else ""
                    return {
                        'type': tool_name,
                        'content': {"value": extra} if extra else {},
                    }

        return None

    # ------------------------------------------------------------------
    # Méthodes utilitaires
    # ------------------------------------------------------------------

    def _split_text_and_action(
        self,
        full_text: str,
        action: Dict[str, Any],
        fence_pattern: str,
        flags: int = 0,
    ) -> Dict[str, Any]:
        """Sépare le texte de l'action et retourne le résultat structuré."""
        text = re.sub(fence_pattern, '', full_text, flags=flags).strip()
        if not text:
            text = ""
        return {'text': text, 'action': action}

    def get_valid_tools(self) -> Set[str]:
        return self.VALID_TOOLS.copy()