snapcontext 2.0.0__tar.gz → 2.2.0__tar.gz

{snapcontext-2.0.0/snapcontext.egg-info → snapcontext-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 2.0.0
+Version: 2.2.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -45,7 +45,7 @@ Dynamic: license-file
 
 # SnapContext
 
-![v2.0.0](https://img.shields.io/badge/version-2.0.0-blue.svg)
+![v2.1.0](https://img.shields.io/badge/version-2.1.0-blue.svg)
 [![PyPI](https://badge.fury.io/py/snapcontext.svg)](https://pypi.org/project/snapcontext/)
 [![CI](https://img.shields.io/github/actions/workflow/status/NicolasBruna24/snapcontext/ci.yml?branch=main&label=tests)](https://github.com/NicolasBruña24/snapcontext/actions)
 ![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)
@@ -104,14 +104,31 @@ snapcontext interactive  # o snapcontext --web
 Auto-detección de proyecto (Flutter, Node/React, Python, Go, Rust…) que ajusta
 carpetas, extensiones y comandos de test por defecto.
 
-## 🛠️ Editor Integrado Propio (v2.0.0)
+## 🛠️ Editor Integrado Propio (v2.2.0)
 
-SnapContext v2.0.0 incluye su propio editor integrado:
+SnapContext incluye su propio editor integrado con soporte de parches unificados
+y edición basada en AST (Árbol Sintáctico) para refactorizaciones precisas:
 - **`--editor propio`**: Aplica cambios directamente y crea copias de seguridad automáticas en `~/.snapcontext/backups/`.
+- **`--modo-edicion {auto,parche,sobrescribir,ast}`**:
+  - `auto` (por defecto): Genera un parche unificado (`git apply` / `patch`), pero
+    para refactorizaciones estructurales intenta primero la edición **AST** y cae a
+    sobrescritura si nada es aplicable.
+  - `ast`: Edita comprendiendo la estructura sintáctica del archivo (Python con
+    `ast`, otros lenguajes con `tree-sitter` si está instalado). Soporta renombrar
+    símbolos, insertar imports y recibir el código completo resultante.
+  - `parche`: Fuerza la aplicación de parches unificados para ediciones precisas.
+  - `sobrescribir`: Sobrescribe el archivo completo.
 - **`--editor aider`** (por defecto): Mantiene el flujo de edición con Aider para máxima compatibilidad.
 
 ```bash
+# Edición precisa mediante diffs unificados
 snapcontext "añadir endpoint de métricas" --editor propio
+
+# Forzar modo parche
+snapcontext "corregir tipado en login" --editor propio --modo-edicion parche
+
+# Refactorización estructural con AST
+snapcontext "renombrar la variable 'usuario' a 'cuenta'" --editor propio --modo-edicion ast
 ```
 
 ## 🧭 Modos y alias

{snapcontext-2.0.0 → snapcontext-2.2.0}/README.md

@@ -1,6 +1,6 @@
 # SnapContext
 
-![v2.0.0](https://img.shields.io/badge/version-2.0.0-blue.svg)
+![v2.1.0](https://img.shields.io/badge/version-2.1.0-blue.svg)
 [![PyPI](https://badge.fury.io/py/snapcontext.svg)](https://pypi.org/project/snapcontext/)
 [![CI](https://img.shields.io/github/actions/workflow/status/NicolasBruna24/snapcontext/ci.yml?branch=main&label=tests)](https://github.com/NicolasBruña24/snapcontext/actions)
 ![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)
@@ -59,14 +59,31 @@ snapcontext interactive  # o snapcontext --web
 Auto-detección de proyecto (Flutter, Node/React, Python, Go, Rust…) que ajusta
 carpetas, extensiones y comandos de test por defecto.
 
-## 🛠️ Editor Integrado Propio (v2.0.0)
+## 🛠️ Editor Integrado Propio (v2.2.0)
 
-SnapContext v2.0.0 incluye su propio editor integrado:
+SnapContext incluye su propio editor integrado con soporte de parches unificados
+y edición basada en AST (Árbol Sintáctico) para refactorizaciones precisas:
 - **`--editor propio`**: Aplica cambios directamente y crea copias de seguridad automáticas en `~/.snapcontext/backups/`.
+- **`--modo-edicion {auto,parche,sobrescribir,ast}`**:
+  - `auto` (por defecto): Genera un parche unificado (`git apply` / `patch`), pero
+    para refactorizaciones estructurales intenta primero la edición **AST** y cae a
+    sobrescritura si nada es aplicable.
+  - `ast`: Edita comprendiendo la estructura sintáctica del archivo (Python con
+    `ast`, otros lenguajes con `tree-sitter` si está instalado). Soporta renombrar
+    símbolos, insertar imports y recibir el código completo resultante.
+  - `parche`: Fuerza la aplicación de parches unificados para ediciones precisas.
+  - `sobrescribir`: Sobrescribe el archivo completo.
 - **`--editor aider`** (por defecto): Mantiene el flujo de edición con Aider para máxima compatibilidad.
 
 ```bash
+# Edición precisa mediante diffs unificados
 snapcontext "añadir endpoint de métricas" --editor propio
+
+# Forzar modo parche
+snapcontext "corregir tipado en login" --editor propio --modo-edicion parche
+
+# Refactorización estructural con AST
+snapcontext "renombrar la variable 'usuario' a 'cuenta'" --editor propio --modo-edicion ast
 ```
 
 ## 🧭 Modos y alias

snapcontext-2.2.0/agentes.py

@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Módulo de Agentes de SnapContext.
+
+Arquitectura de agentes (cada agente se centra en una responsabilidad del
+pipeline y se coordina desde el Orquestador):
+
+  - ``AgenteContexto``: analiza el repositorio y selecciona los archivos
+    relevantes para la tarea. Es el paso "Contexto" (escaneo + selección IA).
+  - ``AgenteEditor``  : recibe órdenes EXACTAS de qué cambiar y ejecuta Aider
+    sobre los archivos seleccionados. No decide qué cambiar; solo aplica órdenes.
+  - ``AgenteTester``  : ejecuta las pruebas y analiza el error devuelto para
+    que el Editor corrija justo lo que falló.
+
+Cada método importa de forma diferida las funciones ya probadas de
+``snapcontext``, para conservar exactamente el comportamiento actual, y añade
+logs de depuración visibles con ``--depurar`` (marcas ``[Agente…]``).
+"""
+
+import subprocess
+from typing import List, Optional, Union
+
+def _tarea_estructura(tarea: str) -> bool:
+    """Heurística simple para `auto`: ¿la tarea parece una refactorización estructural?
+
+    Si es así, merece la pena intentar primero la edición basada en AST.
+    Se normalizan acentos para tolerar variaciones ("renombra"/"renombrar", etc.).
+    """
+    if not tarea:
+        return False
+    import unicodedata as _u
+
+    t = _u.normalize("NFD", tarea.lower())
+    t = "".join(c for c in t if not _u.combining(c))
+    claves = ("refactor", "renombra", "renombrar", "extra", "extraer",
+              "mueve", "mover", "inserta", "insertar", "nueva funcion",
+              "crear funcion", "funcion", "extraccion")
+    return any(k in t for k in claves)
+
+class AgenteContexto:
+    """Agente de Contexto: selecciona los archivos relevantes para la consulta.
+
+    No modifica código: solo elige qué archivos merece la pena abrir/editar.
+    Compone el escaneo local (heurística) y la selección final con el proveedor
+    de IA configurado.
+    """
+
+    def escanear_candidatos(
+        self,
+        consulta: str,
+        directorio: str = ".",
+        carpetas: Optional[List[str]] = None,
+        extensiones: Optional[List[str]] = None,
+        max_candidatos: int = 80,
+    ) -> List[str]:
+        """Escanea ``directorio`` y devuelve los ``max_candidatos`` archivos más
+        relevantes para ``consulta`` usando heurística local (sin llamar a la IA).
+
+        ``extensiones`` (opcional) restringe el escaneo a determinadas
+        extensiones (p. ej. ``[\".dart\"]``).
+
+        Este es el sub-paso 1 del pipeline: reduce el repositorio a candidatos.
+        """
+        import snapcontext as sc
+
+        sc.depurar(
+            f"[AgenteContexto] Escaneando '{directorio}' "
+            f"(carpetas={carpetas}, extensiones={extensiones}, "
+            f"max_candidatos={max_candidatos})..."
+        )
+        resultado = sc.escanear_repositorio(
+            consulta,
+            directorio=directorio,
+            carpetas=carpetas,
+            extensiones=extensiones,
+            max_candidatos=max_candidatos,
+        )
+        sc.depurar(
+            f"[AgenteContexto] {len(resultado)} candidato(s) relevante(s) localmente."
+        )
+        return resultado
+
+    def seleccionar_archivos(
+        self,
+        consulta: str,
+        directorio: str,
+        carpetas: Optional[List[str]],
+        max_archivos: int,
+        provider: str,
+        modelo: str,
+        extensiones: Optional[List[str]] = None,
+    ) -> List[str]:
+        """Pipeline completo del agente de contexto: escanea el repositorio y
+        pide al proveedor IA ``provider`` que se quede con las ``max_archivos``
+        rutas más relevantes para ``consulta``.
+
+        Devuelve la lista final (vacía si no hay candidatos).
+        """
+        import snapcontext as sc
+
+        candidatos = self.escanear_candidatos(
+            consulta,
+            directorio=directorio,
+            carpetas=carpetas,
+            extensiones=extensiones,
+            max_candidatos=max(max_archivos * 3, 1),
+        )
+        if not candidatos:
+            sc.depurar("[AgenteContexto] Sin candidatos; no hay qué seleccionar.")
+            return []
+
+        sc.depurar(
+            f"[AgenteContexto] Seleccionando {max_archivos} rutas "
+            f"(proveedor='{provider}', modelo='{modelo}')..."
+        )
+        return sc.seleccionar_archivos(
+            consulta,
+            candidatos,
+            proveedor=provider,
+            modelo=modelo,
+            max_archivos=max_archivos,
+        )
+
+# __PARTE2__
+class AgenteEditor:
+    """Agente Editor: recibe órdenes exactas y ejecuta Aider.
+
+    No decide de forma autónoma qué cambiar: aplica el ``mensaje`` (normalmente
+    la tarea original y, si viene del ``AgenteTester``, el error exacto) sobre
+    los ``archivos`` indicados por el orquestador.
+    """
+
+    def ejecutar_aider(
+        self,
+        archivos: List[str],
+        mensaje: str,
+        directorio: str,
+        opciones: str = "",
+    ) -> bool:
+        """Ejecuta Aider en ``directorio`` sobre ``archivos`` con ``mensaje``.
+
+        Devuelve ``True`` si Aider terminó con código 0; ``False`` en otro caso.
+        """
+        import snapcontext as sc
+
+        sc.depurar(
+            f"[AgenteEditor] Aider sobre {len(archivos)} archivo(s) en '{directorio}'"
+        )
+        return sc.ejecutar_aider(archivos, mensaje, directorio, opciones)
+
+
+class AgenteEditorPropio:
+    """Agente Editor Propio: editor integrado de SnapContext.
+
+    Aplica cambios directamente sobre el sistema de archivos sin depender de
+    herramientas externas obligatorias.
+    - Fase 1: Sobrescritura segura con copia de seguridad previa en ``~/.snapcontext/backups/``.
+    - Fase 2: Generación y aplicación de parches unificados (unified diffs) con ``git apply`` / ``patch``
+      y fallback automático a sobrescritura.
+    """
+
+    def sobrescribir(
+        self,
+        archivo: str,
+        contenido: str,
+        directorio: str = ".",
+    ) -> bool:
+        """Sobrescribe ``archivo`` con ``contenido`` en ``directorio``.
+
+        Devuelve ``True`` si la escritura fue exitosa, ``False`` si falló.
+        """
+        import snapcontext as sc
+
+        sc.depurar(
+            f"[AgenteEditorPropio] Sobrescribiendo '{archivo}' en '{directorio}'"
+        )
+        return sc._editor_sobrescribir(archivo, contenido, directorio=directorio)
+
+    def aplicar_parche(
+        self,
+        parche: str,
+        directorio: str = ".",
+    ) -> bool:
+        """Aplica un parche unificado en ``directorio``.
+
+        Devuelve ``True`` si se aplicó con éxito, ``False`` si falló.
+        """
+        import snapcontext as sc
+
+        sc.depurar(f"[AgenteEditorPropio] Aplicando parche en '{directorio}'")
+        return sc._aplicar_parche(parche, directorio=directorio)
+
+    def _cadena_modos(self, archivo: str, mensaje: str,
+                      modo_edicion: str) -> List[str]:
+        """Devuelve la cadena de estrategias de edición a intentar para un archivo.
+
+        - 'sobrescribir' → solo sobrescritura.
+        - 'parche'       → solo parche unificado (sin fallback).
+        - 'ast'          → AST y, si falla, sobrescritura.
+        - 'auto'         → AST (si el lenguaje lo permite y la tarea es estructural),
+                           luego parche y, por último, sobrescritura.
+        """
+        import snapcontext as sc
+
+        if modo_edicion == "sobrescribir":
+            return ["sobrescribir"]
+        if modo_edicion == "parche":
+            return ["parche"]
+        if modo_edicion == "ast":
+            return ["ast", "sobrescribir"]
+        # auto: heurística simple según lenguaje y tarea
+        if sc._ast_disponible(archivo) and _tarea_estructura(mensaje):
+            return ["ast", "parche", "sobrescribir"]
+        return ["parche", "sobrescribir"]
+
+    def editar_ast(self, archivo: str, tarea: str,
+                   directorio: str = ".", modelo: Optional[str] = None) -> bool:
+        """Edita ``archivo`` con base en su AST usando el proveedor de IA."""
+        import snapcontext as sc
+
+        pref = sc.cargar_configuracion()
+        proveedor = pref.get("provider") or sc.PROVEEDOR_DEFECTO
+        sc.depurar(f"[AgenteEditorPropio] Editando por AST '{archivo}' en '{directorio}'")
+        return sc._editor_ast(archivo, tarea, directorio=directorio,
+                              proveedor=proveedor, modelo=modelo)
+
+    def _aplicar_modo_parche(self, archivo: str, mensaje: str,
+                             contenido_actual: str, modelo: Optional[str],
+                             directorio: str) -> bool:
+        """Intenta editar `archivo` pidiendo un parche unificado al proveedor."""
+        import snapcontext as sc
+
+        pref = sc.cargar_configuracion()
+        proveedor = pref.get("provider") or sc.PROVEEDOR_DEFECTO
+        prompt = (
+            f"Genera un parche unificado (unified diff) que modifique el archivo para cumplir con la tarea. "
+            f"El parche debe ser aplicable con 'patch -p1' o 'git apply' (encabezados --- a/{archivo} y +++ b/{archivo}).\n\n"
+            f"Tarea: {mensaje}\n"
+            f"Archivo: {archivo}\n\n"
+            f"Contenido actual:\n```\n{contenido_actual}\n```\n\n"
+            f"Devuelve ÚNICAMENTE el diff unificado, sin explicaciones ni rodeos."
+        )
+        respuesta = sc._enviar_al_proveedor(
+            proveedor, modelo, [{"role": "user", "content": prompt}])
+        diff_limpio = respuesta
+        if "--- " in diff_limpio and "+++ " in diff_limpio:
+            idx_inicio = diff_limpio.find("--- ")
+            diff_limpio = diff_limpio[idx_inicio:]
+            if "```" in diff_limpio:
+                diff_limpio = diff_limpio[:diff_limpio.find("```")]
+        if "--- " in diff_limpio and "+++ " in diff_limpio and "@@" in diff_limpio:
+            return self.aplicar_parche(diff_limpio, directorio)
+        return False
+
+    def _aplicar_modo_sobrescribir(self, archivo: str, mensaje: str,
+                                   contenido_actual: str, modelo: Optional[str],
+                                   directorio: str) -> bool:
+        """Sobrescribe `archivo` con el código completo que devuelve el proveedor."""
+        import snapcontext as sc
+
+        pref = sc.cargar_configuracion()
+        proveedor = pref.get("provider") or sc.PROVEEDOR_DEFECTO
+        prompt = (
+            f"Modifica el siguiente archivo para cumplir con la tarea.\n\n"
+            f"Tarea: {mensaje}\n"
+            f"Archivo: {archivo}\n\n"
+            f"Contenido actual:\n```\n{contenido_actual}\n```\n\n"
+            f"Devuelve ÚNICAMENTE el código completo resultante, sin explicaciones ni markdown."
+        )
+        nuevo_contenido = sc._enviar_al_proveedor(
+            proveedor, modelo, [{"role": "user", "content": prompt}])
+        if nuevo_contenido.startswith("```"):
+            lineas = nuevo_contenido.splitlines()
+            if len(lineas) >= 2 and lineas[-1].startswith("```"):
+                nuevo_contenido = "\n".join(lineas[1:-1])
+        return self.sobrescribir(archivo, nuevo_contenido, directorio)
+
+    def ejecutar(
+        self,
+        archivos: List[str],
+        mensaje: str,
+        directorio: str = ".",
+        modo_edicion: str = "auto",
+        modelo: Optional[str] = None,
+    ) -> bool:
+        """Aplica las modificaciones para `archivos` con el `mensaje` especificado.
+
+        - modo_edicion == 'parche': intenta aplicar parche unificado (falla si no puede).
+        - modo_edicion == 'sobrescribir': aplica directamente sobrescritura de archivo.
+        - modo_edicion == 'ast': edita con base en el AST y cae a sobrescritura si falla.
+        - modo_edicion == 'auto': decide por heurística (AST para refactorizaciones,
+          parche, y fallback a sobrescritura).
+        """
+        import snapcontext as sc
+        from pathlib import Path
+
+        raiz = Path(directorio).resolve()
+        todo_ok = True
+
+        for arch in archivos:
+            camino = (raiz / arch).resolve()
+            contenido_actual = ""
+            if camino.is_file():
+                try:
+                    contenido_actual = camino.read_text(encoding="utf-8",
+                                                        errors="replace")
+                except Exception:
+                    pass
+
+            cadena = self._cadena_modos(arch, mensaje, modo_edicion)
+            conseguido = False
+            for estrategia in cadena:
+                try:
+                    if estrategia == "ast":
+                        conseguido = self.editar_ast(arch, mensaje,
+                                                     str(raiz), modelo)
+                    elif estrategia == "parche":
+                        conseguido = self._aplicar_modo_parche(
+                            arch, mensaje, contenido_actual, modelo, str(raiz))
+                    elif estrategia == "sobrescribir":
+                        conseguido = self._aplicar_modo_sobrescribir(
+                            arch, mensaje, contenido_actual, modelo, str(raiz))
+                    else:
+                        conseguido = False
+                except Exception as exc:
+                    sc.depurar(
+                        f"[AgenteEditorPropio] {estrategia} falló para '{arch}': {exc}")
+                    conseguido = False
+                if conseguido:
+                    break
+            if not conseguido:
+                sc.error(f"[AgenteEditorPropio] No se pudo editar '{arch}'.")
+                todo_ok = False
+
+        return todo_ok
+
+
+class AgenteEditorAST:
+    """Agente Editor AST (Fase 3): ediciones precisas basadas en árbol sintáctico.
+
+    Trabaja directamente con el AST del archivo (Python con ``ast``; otros
+    lenguajes con ``tree-sitter`` si está instalado) pidiendo al proveedor
+    operaciones de modificación del árbol o el código completo resultante.
+    """
+
+    def editar(
+        self,
+        archivos: List[str],
+        mensaje: str,
+        directorio: str = ".",
+        modelo: Optional[str] = None,
+    ) -> bool:
+        """Aplica a cada archivo una edición guiada por AST. Devuelve bool."""
+        todo = True
+        for archivo in archivos:
+            if not self.editar_archivo(archivo, mensaje,
+                                       directorio=directorio, modelo=modelo):
+                todo = False
+        return todo
+
+    def editar_archivo(
+        self,
+        archivo: str,
+        tarea: str,
+        directorio: str = ".",
+        modelo: Optional[str] = None,
+    ) -> bool:
+        """Edita un único archivo con AST. Devuelve ``True`` si tuvo éxito."""
+        import snapcontext as sc
+
+        pref = sc.cargar_configuracion()
+        proveedor = pref.get("provider") or sc.PROVEEDOR_DEFECTO
+        sc.depurar(f"[AgenteEditorAST] AST sobre '{archivo}' en '{directorio}'")
+        return sc._editor_ast(archivo, tarea, directorio=directorio,
+                              proveedor=proveedor, modelo=modelo)
+
+
+class AgenteTester:
+    """Agente Tester: ejecuta las pruebas y analiza los errores devueltos.
+
+    Su salida alimenta al ``AgenteEditor`` para que corrija justo lo que falló,
+    sin que Aider pierda de vista la tarea original.
+    """
+
+    def ejecutar_pruebas(
+        self, comando: List[str], directorio: str
+    ) -> "subprocess.CompletedProcess":
+        """Ejecuta ``comando`` (lista de argv) en ``directorio`` capturando la salida.
+
+        Devuelve el ``subprocess.CompletedProcess`` para poder analizarlo después.
+        """
+        import snapcontext as sc
+
+        sc.depurar(f"[AgenteTester] Ejecutando pruebas: {' '.join(comando)}")
+        return subprocess.run(
+            comando, cwd=directorio, capture_output=True, text=True
+        )
+
+    def analizar_error(
+        self, salida: Union["subprocess.CompletedProcess", str]
+    ) -> str:
+        """Normaliza la salida de unas pruebas que fallaron para entregársela a Aider.
+
+        Acepta el ``CompletedProcess`` devuelto por :meth:`ejecutar_pruebas` o un
+        ``str`` con la salida cruda. Limpia códigos ANSI y recorta demasiado
+        texto para no llenar el contexto de Aider.
+        """
+        import snapcontext as sc
+
+        if hasattr(salida, "stdout"):
+            # Objeto CompletedProcess → reutilizamos el normalizador de snapcontext.
+            return sc._extraer_error(salida)
+
+        limpieza: str = salida or ""
+        import re as _re
+
+        limpieza = _re.sub(r"\x1b\[[0-9;]*m", "", limpieza)
+        limpieza = limpieza.strip() or "(el comando de prueba no devolvió salida)"
+        limite = getattr(sc, "MAX_ERROR_SALIDA", 4000)
+        if len(limpieza) > limite:
+            limpieza = "\n--- (salida recortada) ---\n" + limpieza[-limite:]
+        return limpieza

{snapcontext-2.0.0 → snapcontext-2.2.0}/orquestador.py

@@ -20,7 +20,8 @@ import shlex
 import sys
 from typing import List, Optional, Tuple
 
-from agentes import AgenteContexto, AgenteEditor, AgenteEditorPropio, AgenteTester
+from agentes import (AgenteContexto, AgenteEditor, AgenteEditorAST,
+                     AgenteEditorPropio, AgenteTester)
 
 # Centinela diferenciado del None de "aborto": _planificar lo devuelve cuando
 # el pipeline termina de forma exitosa y temprana (p. ej. --vista-previa).
@@ -40,6 +41,7 @@ class Orquestador:
         self.agente_contexto = AgenteContexto()
         self.agente_editor = AgenteEditor()
         self.agente_editor_propio = AgenteEditorPropio()
+        self.agente_editor_ast = AgenteEditorAST()
         self.agente_tester = AgenteTester()
         self.evento_callback = evento_callback
 
@@ -180,38 +182,14 @@ class Orquestador:
                 if editor_tipo == "propio":
                     sc.depurar("[Orquestador] Modo edición directa (AgenteEditorPropio).")
                     self._emitir_tipo("editor", accion="iniciar", archivos=seleccion)
-                    pref = sc.cargar_configuracion()
-                    proveedor = pref.get("provider") or sc.PROVEEDOR_DEFECTO
-                    ok = True
-                    for arch in seleccion:
-                        camino = (raiz / arch).resolve()
-                        contenido_actual = ""
-                        if camino.is_file():
-                            try:
-                                contenido_actual = camino.read_text(encoding="utf-8", errors="replace")
-                            except Exception:
-                                pass
-                        prompt_editor = (
-                            f"Modifica el siguiente archivo para cumplir con la tarea.\n\n"
-                            f"Tarea: {consulta}\n"
-                            f"Archivo: {arch}\n\n"
-                            f"Contenido actual:\n```\n{contenido_actual}\n```\n\n"
-                            f"Devuelve ÚNICAMENTE el código completo resultante, sin explicaciones ni markdown."
-                        )
-                        try:
-                            nuevo_contenido = sc._enviar_al_proveedor(
-                                proveedor, getattr(args, "modelo", None),
-                                [{"role": "user", "content": prompt_editor}]
-                            )
-                            if nuevo_contenido.startswith("```"):
-                                lineas = nuevo_contenido.splitlines()
-                                if len(lineas) >= 2 and lineas[-1].startswith("```"):
-                                    nuevo_contenido = "\n".join(lineas[1:-1])
-                            if not self.agente_editor_propio.sobrescribir(arch, nuevo_contenido, str(raiz)):
-                                ok = False
-                        except Exception as exc:
-                            sc.error(f"Error generando cambios para {arch}: {exc}")
-                            ok = False
+                    modo_ed = getattr(args, "modo_edicion", "auto") or "auto"
+                    ok = self.agente_editor_propio.ejecutar(
+                        seleccion,
+                        consulta,
+                        directorio=str(raiz),
+                        modo_edicion=modo_ed,
+                        modelo=getattr(args, "modelo", None),
+                    )
                     self._emitir_tipo("editor", accion="fin", ok=ok)
                 else:
                     sc.depurar("[Orquestador] Modo edición directa (AgenteEditor).")