snapcontext 3.3.0__tar.gz → 3.4.0__tar.gz

{snapcontext-3.3.0/snapcontext.egg-info → snapcontext-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 3.3.0
+Version: 3.4.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.1.0](https://img.shields.io/badge/version-2.1.0-blue.svg)
+![v3.4.0](https://img.shields.io/badge/version-3.4.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)
@@ -199,6 +199,37 @@ 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
+
+# Validación de sintaxis desactivada (comportamiento previo a v3.4.0)
+snapcontext "corregir tipado" --editor propio --no-validar-sintaxis
+```
+
+### Validación de sintaxis antes de guardar (v3.4.0)
+
+Cuando uses `--editor propio`, SnapContext **valida la sintaxis** del código que
+ha generado la IA **antes de escribirlo en disco**. Si la validación falla, el
+cambio se rechaza y se le envía el error al proveedor para que lo corrija,
+repitiéndose hasta `--max-intentos-validacion` intentos (por defecto 3). Si tras
+esos intentos el código sigue roto, se **cancela la edición** y el archivo queda
+intacto.
+
+- Se detecta el lenguaje del archivo y se usa el validador adecuado:
+  Python (`py_compile`), JavaScript/TypeScript (`node --check`), Dart
+  (`dart analyze` → `dart format`), Go (`go build -n` → `gofmt -e`), Rust
+  (`rustc --parse-only`), Java (`javac -Xlint:none`), C/C++ (`gcc`/`clang
+  -fsyntax-only`). Si no hay validador o comando disponible, se omite la
+  validación (solo aviso en logs con `--depurar`).
+- La validación se hace sobre un **archivo temporal**, nunca toca el original.
+- Flag `--validar` (por defecto activado) / `--no-validar-sintaxis` para
+  desactivarla. Nota: el nombre usa `--no-validar-sintaxis` porque
+  `--no-validar` ya es alias de `--iniciar-proyecto`.
+
+```bash
+# Desactivar la validación por completo (comportamiento anterior)
+snapcontext "..." --editor propio --no-validar-sintaxis
+
+# Ajustar el número de reintentos
+snapcontext "..." --editor propio --max-intentos-validacion 5
 ```
 
 ## 🧭 Modos y alias
@@ -1013,6 +1044,12 @@ locales y te deja elegir con las flechas:
 | `--url-defecto` | `http://localhost:5000` | URL para abrir el navegador si Flutter no reporta una |
 | `--comando-test` | `"flutter test"` | Comando del bucle de pruebas |
 | `--max-iteraciones` | `3` | Iteraciones máximas del bucle |
+| `--validar` | on | Valida la sintaxis del código antes de guardar en el editor propio |
+| `--no-validar-sintaxis` | off | Desactiva la validación de sintaxis del editor propio |
+| `--max-intentos-validacion` | `3` | Intentos de validación de sintaxis antes de cancelar la edición |
+
+> **Nota:** el flag negativo de validación de sintaxis se llama `--no-validar-sintaxis`
+> porque `--no-validar` ya existe como alias de `--iniciar-proyecto`.
 
 ---
 

{snapcontext-3.3.0 → snapcontext-3.4.0}/README.md

@@ -1,6 +1,6 @@
 # SnapContext
 
-![v2.1.0](https://img.shields.io/badge/version-2.1.0-blue.svg)
+![v3.4.0](https://img.shields.io/badge/version-3.4.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)
@@ -154,6 +154,37 @@ 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
+
+# Validación de sintaxis desactivada (comportamiento previo a v3.4.0)
+snapcontext "corregir tipado" --editor propio --no-validar-sintaxis
+```
+
+### Validación de sintaxis antes de guardar (v3.4.0)
+
+Cuando uses `--editor propio`, SnapContext **valida la sintaxis** del código que
+ha generado la IA **antes de escribirlo en disco**. Si la validación falla, el
+cambio se rechaza y se le envía el error al proveedor para que lo corrija,
+repitiéndose hasta `--max-intentos-validacion` intentos (por defecto 3). Si tras
+esos intentos el código sigue roto, se **cancela la edición** y el archivo queda
+intacto.
+
+- Se detecta el lenguaje del archivo y se usa el validador adecuado:
+  Python (`py_compile`), JavaScript/TypeScript (`node --check`), Dart
+  (`dart analyze` → `dart format`), Go (`go build -n` → `gofmt -e`), Rust
+  (`rustc --parse-only`), Java (`javac -Xlint:none`), C/C++ (`gcc`/`clang
+  -fsyntax-only`). Si no hay validador o comando disponible, se omite la
+  validación (solo aviso en logs con `--depurar`).
+- La validación se hace sobre un **archivo temporal**, nunca toca el original.
+- Flag `--validar` (por defecto activado) / `--no-validar-sintaxis` para
+  desactivarla. Nota: el nombre usa `--no-validar-sintaxis` porque
+  `--no-validar` ya es alias de `--iniciar-proyecto`.
+
+```bash
+# Desactivar la validación por completo (comportamiento anterior)
+snapcontext "..." --editor propio --no-validar-sintaxis
+
+# Ajustar el número de reintentos
+snapcontext "..." --editor propio --max-intentos-validacion 5
 ```
 
 ## 🧭 Modos y alias
@@ -968,6 +999,12 @@ locales y te deja elegir con las flechas:
 | `--url-defecto` | `http://localhost:5000` | URL para abrir el navegador si Flutter no reporta una |
 | `--comando-test` | `"flutter test"` | Comando del bucle de pruebas |
 | `--max-iteraciones` | `3` | Iteraciones máximas del bucle |
+| `--validar` | on | Valida la sintaxis del código antes de guardar en el editor propio |
+| `--no-validar-sintaxis` | off | Desactiva la validación de sintaxis del editor propio |
+| `--max-intentos-validacion` | `3` | Intentos de validación de sintaxis antes de cancelar la edición |
+
+> **Nota:** el flag negativo de validación de sintaxis se llama `--no-validar-sintaxis`
+> porque `--no-validar` ya existe como alias de `--iniciar-proyecto`.
 
 ---
 

{snapcontext-3.3.0 → snapcontext-3.4.0}/agentes.py

@@ -232,9 +232,55 @@ class AgenteEditorPropio:
         return sc._editor_ast(archivo, tarea, directorio=directorio,
                               proveedor=proveedor, modelo=modelo)
 
+    @staticmethod
+    def _aplicar_parche_preview(parche: str, contenido_actual: str):
+        """Aplica ``parche`` a ``contenido_actual`` **en memoria** para poder
+        validar la sintaxis del resultado sin tocar el archivo real.
+
+        Reutiliza la segmentación de hunks de ``_parsear_hunks`` y aplica cada
+        hunk con tolerancia a pequeños desfases. Devuelve ``(resultado, n)``
+        donde ``n`` es el número de hunks aplicados (0 ⇒ no se pudo reproducir).
+        """
+        import snapcontext as sc
+
+        resultado = (contenido_actual or "").splitlines()
+        desplazamiento = 0
+        aplicados = 0
+        for inicio_orig, cambios in sc._parsear_hunks(parche):
+            base = max(inicio_orig - 1 + desplazamiento, 0)
+            n_borrados = sum(1 for marca, _ in cambios if marca != "+")
+            nuevos = [texto for marca, texto in cambios if marca != "-"]
+
+            posicion = -1
+            for delta in (0, 1, -1, 2, -2, 3, -3, 5, -5, 10, -10):
+                candidato = base + delta
+                if candidato < 0 or candidato > len(resultado):
+                    continue
+                idx = candidato
+                encaja = True
+                for marca, texto in cambios:
+                    if marca == "+":
+                        continue
+                    if idx >= len(resultado) or resultado[idx] != texto:
+                        encaja = False
+                        break
+                    idx += 1
+                if encaja:
+                    posicion = candidato
+                    break
+            if posicion < 0:
+                continue
+
+            resultado[posicion:posicion + n_borrados] = nuevos
+            desplazamiento += len(nuevos) - n_borrados
+            aplicados += 1
+
+        return "\n".join(resultado) + "\n", aplicados
+
     def _aplicar_modo_parche(self, archivo: str, mensaje: str,
                              contenido_actual: str, modelo: Optional[str],
-                             directorio: str) -> bool:
+                             directorio: str, validar: bool = True,
+                             max_intentos_validacion: int = 3) -> bool:
         """Intenta editar `archivo` pidiendo un parche unificado al proveedor."""
         import snapcontext as sc
 
@@ -243,57 +289,134 @@ class AgenteEditorPropio:
         lenguaje = sc._lenguaje_archivo(archivo, contenido_actual) or "?"
         num_lineas = (contenido_actual.count("\n") + 1
                       if contenido_actual else 0)
-        prompt = (
-            f"Genera un parche unificado (unified diff) que modifique el archivo "
-            f"para cumplir con la tarea con precisión máxima.\n"
-            f"El parche debe ser aplicable con 'patch -p1' o 'git apply' "
-            f"(encabezados --- a/{archivo} y +++ b/{archivo}).\n\n"
-            f"Tarea: {mensaje}\n"
-            f"Archivo: {archivo}  (lenguaje: {lenguaje}, {num_lineas} líneas)\n\n"
-            f"Instrucciones:\n"
-            f"- Incluye suficiente contexto (3 líneas) para anclar cada hunk.\n"
-            f"- Conserva el estilo existente (indentación, comillas).\n"
-            f"- Modifica SOLO lo necesario; no reorganices el resto del archivo.\n\n"
-            f"Contenido actual completo:\n```{lenguaje}\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:
-            # v3.3.0: validación previa + resolución de conflictos.
-            return self.aplicar_parche(diff_limpio, directorio,
-                                       contenido_esperado=contenido_actual)
+        max_val = max(1, int(max_intentos_validacion))
+
+        error_msj = ""
+        for intento in range(1, max_val + 1):
+            prompt = (
+                f"Genera un parche unificado (unified diff) que modifique el archivo "
+                f"para cumplir con la tarea con precisión máxima.\n"
+                f"El parche debe ser aplicable con 'patch -p1' o 'git apply' "
+                f"(encabezados --- a/{archivo} y +++ b/{archivo}).\n\n"
+                f"Tarea: {mensaje}\n"
+                f"Archivo: {archivo}  (lenguaje: {lenguaje}, {num_lineas} líneas)\n\n"
+                f"Instrucciones:\n"
+                f"- Incluye suficiente contexto (3 líneas) para anclar cada hunk.\n"
+                f"- Conserva el estilo existente (indentación, comillas).\n"
+                f"- Modifica SOLO lo necesario; no reorganices el resto del archivo.\n"
+            )
+            if error_msj:
+                prompt += (
+                    f"\nTu intento anterior produjo un error de sintaxis que debes "
+                    f"corregir:\n{error_msj}\n\n"
+                    f"Mantén el objetivo de la tarea pero arregla ese error.\n"
+                )
+            prompt += (
+                f"\nContenido actual completo:\n```{lenguaje}\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 not ("--- " in diff_limpio and "+++ " in diff_limpio
+                    and "@@" in diff_limpio):
+                return False
+
+            if not validar:
+                # v3.3.0: validación previa + resolución de conflictos.
+                return self.aplicar_parche(diff_limpio, directorio,
+                                           contenido_esperado=contenido_actual)
+
+            # v3.4.0: validar la sintaxis del contenido resultante.
+            preview, aplicados = self._aplicar_parche_preview(
+                diff_limpio, contenido_actual)
+            if aplicados == 0:
+                # No se pudo reproducir en memoria → se omite la validación.
+                return self.aplicar_parche(diff_limpio, directorio,
+                                           contenido_esperado=contenido_actual)
+
+            sc.info(f"Validando sintaxis de {archivo}...")
+            exito, err = sc._validar_sintaxis(archivo, preview, directorio)
+            if exito:
+                sc.exito("Sintaxis válida.")
+                return self.aplicar_parche(diff_limpio, directorio,
+                                           contenido_esperado=contenido_actual)
+
+            error_msj = err
+            if intento < max_val:
+                sc.error(
+                    f"Error de sintaxis: {err}. "
+                    f"Reintentando ({intento}/{max_val})...")
+            else:
+                sc.error(
+                    f"No se pudo validar tras {max_val} intentos. "
+                    f"Edición cancelada.")
+                return False
         return False
 
     def _aplicar_modo_sobrescribir(self, archivo: str, mensaje: str,
                                    contenido_actual: str, modelo: Optional[str],
-                                   directorio: str) -> bool:
+                                   directorio: str, validar: bool = True,
+                                   max_intentos_validacion: int = 3) -> 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
         lenguaje = sc._lenguaje_archivo(archivo, contenido_actual) or "?"
-        prompt = (
-            f"Modifica el siguiente archivo ({lenguaje}) para cumplir con la "
-            f"tarea, conservando el estilo existente y cambiando solo lo necesario.\n\n"
-            f"Tarea: {mensaje}\n"
-            f"Archivo: {archivo}  (lenguaje: {lenguaje})\n\n"
-            f"Contenido actual completo:\n```{lenguaje}\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])
+        max_val = max(1, int(max_intentos_validacion))
+
+        error_msj = ""
+        nuevo_contenido = ""
+        for intento in range(1, max_val + 1):
+            prompt = (
+                f"Modifica el siguiente archivo ({lenguaje}) para cumplir con la "
+                f"tarea, conservando el estilo existente y cambiando solo lo necesario.\n\n"
+                f"Tarea: {mensaje}\n"
+                f"Archivo: {archivo}  (lenguaje: {lenguaje})\n"
+            )
+            if error_msj:
+                prompt += (
+                    f"\nTu intento anterior produjo un error de sintaxis que debes "
+                    f"corregir:\n{error_msj}\n\n"
+                    f"Mantén el objetivo de la tarea pero arregla ese error.\n"
+                )
+            prompt += (
+                f"\nContenido actual completo:\n```{lenguaje}\n{contenido_actual}\n```\n\n"
+                f"Devuelve ÚNICAMENTE el código completo resultante, sin explicaciones ni markdown."
+            )
+            respuesta = sc._enviar_al_proveedor(
+                proveedor, modelo, [{"role": "user", "content": prompt}])
+            nuevo_contenido = respuesta
+            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 validar:
+                break
+
+            sc.info(f"Validando sintaxis de {archivo}...")
+            exito, err = sc._validar_sintaxis(archivo, nuevo_contenido, directorio)
+            if exito:
+                sc.exito("Sintaxis válida.")
+                break
+            error_msj = err
+            if intento < max_val:
+                sc.error(
+                    f"Error de sintaxis: {err}. "
+                    f"Reintentando ({intento}/{max_val})...")
+            else:
+                sc.error(
+                    f"No se pudo validar tras {max_val} intentos. "
+                    f"Edición cancelada.")
+                return False
+
         return self.sobrescribir(archivo, nuevo_contenido, directorio)
 
     def ejecutar(
@@ -303,6 +426,8 @@ class AgenteEditorPropio:
         directorio: str = ".",
         modo_edicion: str = "auto",
         modelo: Optional[str] = None,
+        validar: bool = True,
+        max_intentos_validacion: int = 3,
     ) -> bool:
         """Aplica las modificaciones para `archivos` con el `mensaje` especificado.
 
@@ -353,10 +478,14 @@ class AgenteEditorPropio:
                                                      str(raiz), modelo)
                     elif estrategia == "parche":
                         conseguido = self._aplicar_modo_parche(
-                            arch, mensaje, contenido_actual, modelo, str(raiz))
+                            arch, mensaje, contenido_actual, modelo, str(raiz),
+                            validar=validar,
+                            max_intentos_validacion=max_intentos_validacion)
                     elif estrategia == "sobrescribir":
                         conseguido = self._aplicar_modo_sobrescribir(
-                            arch, mensaje, contenido_actual, modelo, str(raiz))
+                            arch, mensaje, contenido_actual, modelo, str(raiz),
+                            validar=validar,
+                            max_intentos_validacion=max_intentos_validacion)
                     else:
                         conseguido = False
                 except Exception as exc:

{snapcontext-3.3.0 → snapcontext-3.4.0}/orquestador.py

@@ -190,6 +190,9 @@ class Orquestador:
                         directorio=str(raiz),
                         modo_edicion=modo_ed,
                         modelo=getattr(args, "modelo", None),
+                        validar=getattr(args, "validar", True),
+                        max_intentos_validacion=getattr(
+                            args, "max_intentos_validacion", 3),
                     )
                     self._emitir_tipo("editor", accion="fin", ok=ok)
                 else:

{snapcontext-3.3.0 → snapcontext-3.4.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 # Nombre verificado disponible en PyPI (18/08/2026): pypi.org/pypi/snapcontext → 404.
 # Alternativas si algún día estuviera ocupado: "snapcontext-cli" o "snapcontext-tool".
 name = "snapcontext"
-version = "3.3.0"
+version = "3.4.0"
 description = "SnapContext: Asistente de IA con contexto automático para desarrollo"
 readme = "README.md"
 requires-python = ">=3.9"

{snapcontext-3.3.0 → snapcontext-3.4.0/snapcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 3.3.0
+Version: 3.4.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.1.0](https://img.shields.io/badge/version-2.1.0-blue.svg)
+![v3.4.0](https://img.shields.io/badge/version-3.4.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)
@@ -199,6 +199,37 @@ 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
+
+# Validación de sintaxis desactivada (comportamiento previo a v3.4.0)
+snapcontext "corregir tipado" --editor propio --no-validar-sintaxis
+```
+
+### Validación de sintaxis antes de guardar (v3.4.0)
+
+Cuando uses `--editor propio`, SnapContext **valida la sintaxis** del código que
+ha generado la IA **antes de escribirlo en disco**. Si la validación falla, el
+cambio se rechaza y se le envía el error al proveedor para que lo corrija,
+repitiéndose hasta `--max-intentos-validacion` intentos (por defecto 3). Si tras
+esos intentos el código sigue roto, se **cancela la edición** y el archivo queda
+intacto.
+
+- Se detecta el lenguaje del archivo y se usa el validador adecuado:
+  Python (`py_compile`), JavaScript/TypeScript (`node --check`), Dart
+  (`dart analyze` → `dart format`), Go (`go build -n` → `gofmt -e`), Rust
+  (`rustc --parse-only`), Java (`javac -Xlint:none`), C/C++ (`gcc`/`clang
+  -fsyntax-only`). Si no hay validador o comando disponible, se omite la
+  validación (solo aviso en logs con `--depurar`).
+- La validación se hace sobre un **archivo temporal**, nunca toca el original.
+- Flag `--validar` (por defecto activado) / `--no-validar-sintaxis` para
+  desactivarla. Nota: el nombre usa `--no-validar-sintaxis` porque
+  `--no-validar` ya es alias de `--iniciar-proyecto`.
+
+```bash
+# Desactivar la validación por completo (comportamiento anterior)
+snapcontext "..." --editor propio --no-validar-sintaxis
+
+# Ajustar el número de reintentos
+snapcontext "..." --editor propio --max-intentos-validacion 5
 ```
 
 ## 🧭 Modos y alias
@@ -1013,6 +1044,12 @@ locales y te deja elegir con las flechas:
 | `--url-defecto` | `http://localhost:5000` | URL para abrir el navegador si Flutter no reporta una |
 | `--comando-test` | `"flutter test"` | Comando del bucle de pruebas |
 | `--max-iteraciones` | `3` | Iteraciones máximas del bucle |
+| `--validar` | on | Valida la sintaxis del código antes de guardar en el editor propio |
+| `--no-validar-sintaxis` | off | Desactiva la validación de sintaxis del editor propio |
+| `--max-intentos-validacion` | `3` | Intentos de validación de sintaxis antes de cancelar la edición |
+
+> **Nota:** el flag negativo de validación de sintaxis se llama `--no-validar-sintaxis`
+> porque `--no-validar` ya existe como alias de `--iniciar-proyecto`.
 
 ---
 

{snapcontext-3.3.0 → snapcontext-3.4.0}/snapcontext.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ tests/test_plan_012.py
 tests/test_plan_mcp_230.py
 tests/test_v010.py
 tests/test_validacion_130.py
+tests/test_validacion_sintaxis_340.py
 tests/test_vscode_016.py
 tests/test_vscode_ts_320.py
 tests/test_web_120.py

{snapcontext-3.3.0 → snapcontext-3.4.0}/snapcontext.py

@@ -56,7 +56,7 @@ import unicodedata
 import warnings
 import webbrowser
 from pathlib import Path
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional, Tuple, Union
 from urllib.parse import urlparse
 
 # `google-generativeai` es la dependencia del proveedor por defecto (Gemini).
@@ -111,7 +111,7 @@ except ImportError:  # pragma: no cover
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 
-VERSION = "3.3.0"
+VERSION = "3.4.0"
 
 # v3.1.0 — Claves de API reconocidas para el modo por defecto (offline).
 CLAVES_API_CONOCIDAS = (
@@ -301,6 +301,7 @@ MAX_ARCHIVOS_DEFECTO = 3                           # archivos que recibe Aider
 MAX_CANDIDATOS_DEFECTO = 80                        # candidatos que se envían al selector IA
 MAX_ITERACIONES_TEST_DEFECTO = 3
 COMANDO_TEST_DEFECTO = "flutter test"
+MAX_INTENTOS_VALIDACION = 3                        # reintentos de validación del editor propio
 
 # ---------------------------------------------------------------------------
 # Proveedores de IA para la selección de archivos
@@ -1732,6 +1733,127 @@ def _editor_sobrescribir(archivo: str, contenido: str,
         return False
 
 
+def _comandos_validacion(lenguaje: str, archivo_tmp: str) -> List[List[str]]:
+    """Comandos de validación sintáctica para ``lenguaje``.
+
+    Devuelve una lista de candidatos (cada uno un argv con ``archivo_tmp`` ya
+    resuelto). Cuando un lenguaje admite un validador de reserva (p. ej.
+    ``dart analyze`` → ``dart format``), se incluyen en orden de preferencia.
+    Devuelve ``[]`` si no existe validador para el lenguaje.
+    """
+    if not lenguaje:
+        return []
+    if lenguaje in ("python", "py", "python3"):
+        return [[sys.executable, "-m", "py_compile", archivo_tmp]]
+    if lenguaje in ("javascript", "typescript", "tsx", "js", "ts", "node",
+                    "jsx", "mjs", "cjs", "mts", "cts"):
+        return [["node", "--check", archivo_tmp]]
+    if lenguaje == "dart":
+        return [["dart", "analyze", archivo_tmp],
+                ["dart", "format", "--output=none", archivo_tmp]]
+    if lenguaje == "go":
+        return [["go", "build", "-n", archivo_tmp],
+                ["gofmt", "-e", archivo_tmp]]
+    if lenguaje in ("rust", "rs"):
+        return [["rustc", "--parse-only", archivo_tmp]]
+    if lenguaje in ("java",):
+        return [["javac", "-Xlint:none", archivo_tmp]]
+    if lenguaje in ("c", "h"):
+        return [["gcc", "-fsyntax-only", archivo_tmp],
+                ["clang", "-fsyntax-only", archivo_tmp]]
+    if lenguaje in ("cpp", "cc", "cxx", "hpp", "hh", "hxx", "c++"):
+        return [["g++", "-fsyntax-only", archivo_tmp],
+                ["clang++", "-fsyntax-only", archivo_tmp]]
+    return []
+
+
+def _validar_sintaxis(archivo: str, contenido: str,
+                      directorio: str = ".") -> Tuple[bool, str]:
+    """Valida la sintaxis de ``contenido`` como si fuese el de ``archivo``.
+
+    Escribe el ``contenido`` en un archivo temporal (siempre conserva la
+    extensión del archivo original para que el parser/linter lo reconozca) y
+    ejecuta el comando de validación correspondiente al lenguaje detectado con
+    ``_lenguaje_archivo``. Nunca toca el archivo original.
+
+    Devuelve ``(exito, mensaje_error)``:
+      - ``(True, "")`` si la validación pasó, o si no hay validador / comando
+        disponible (se omite la validación).
+      - ``(False, mensaje)`` si el validador rechazó el contenido o hubo timeout.
+    """
+    lenguaje = _lenguaje_archivo(archivo, contenido) or ""
+    if not lenguaje:
+        depurar(
+            f"[validar-sintaxis] Sin validador para '{archivo}' (lenguaje "
+            f"desconocido); se omite la validación."
+        )
+        return True, ""
+
+    suffix = Path(archivo).suffix or ".txt"
+    archivo_tmp = ""
+    try:
+        fd, archivo_tmp = tempfile.mkstemp(
+            suffix=suffix, prefix=".snapcontext_validacion_")
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            fh.write(contenido or "")
+
+        comandos = _comandos_validacion(lenguaje, archivo_tmp)
+        if not comandos:
+            depurar(
+                f"[validar-sintaxis] Sin validador para '{lenguaje}'; "
+                "se omite la validación."
+            )
+            return True, ""
+
+        for cmd in comandos:
+            binario = cmd[0]
+            if shutil.which(binario) is None:
+                depurar(
+                    f"[validar-sintaxis] Comando '{binario}' no disponible; "
+                    "se busca alternativa."
+                )
+                continue
+            try:
+                proc = subprocess.run(
+                    cmd, capture_output=True, text=True, timeout=60,
+                    cwd=directorio or ".",
+                )
+            except subprocess.TimeoutExpired:
+                error(
+                    f"[validar-sintaxis] El comando '{binario}' excedió el "
+                    f"tiempo límite al validar '{archivo}'."
+                )
+                return False, (
+                    f"el comando '{binario}' excedió el tiempo límite de validación"
+                )
+            except (OSError, ValueError):
+                continue          # no se pudo lanzar → probar candidato siguiente
+
+            if proc.returncode == 0:
+                return True, ""
+            # Código de salida != 0 ⇒ error sintáctico (o validador fallo).
+            salida = (proc.stderr or "").strip()
+            if not salida:
+                salida = (proc.stdout or "").strip()
+            mensaje = salida or (
+                f"el validador '{binario}' falló (código {proc.returncode})"
+            )
+            return False, mensaje
+
+        # Ningún candidato disponible → se omite la validación.
+        depurar(
+            f"[validar-sintaxis] Ningún validador disponible para '{lenguaje}'; "
+            "se omite la validación."
+        )
+        return True, ""
+    finally:
+        if archivo_tmp:
+            try:
+                os.unlink(archivo_tmp)
+            except OSError:
+                pass
+
+
 def _generar_parche(original: str, nuevo: str, ruta_archivo: str) -> str:
     """Genera un parche unificado (unified diff) entre `original` y `nuevo`.
 
@@ -4082,6 +4204,9 @@ def _ejecutar_paso_plan(paso: dict, args: argparse.Namespace,
             directorio=str(ruta_raiz),
             modo_edicion=modo_ed,
             modelo=getattr(args, "modelo", None),
+            validar=getattr(args, "validar", True),
+            max_intentos_validacion=getattr(
+                args, "max_intentos_validacion", MAX_INTENTOS_VALIDACION),
         )
         return (todo_ok, f"EditorPropio sobre {len(seleccion)} archivo(s)")
 
@@ -6842,7 +6967,8 @@ def _pintar(texto: str, clave: str) -> str:
 # Categorías en orden de aparición; cada opción se muestra una sola vez.
 CATEGORIAS_AYUDA = (
     ("Modos de ejecución",
-     ("--plan", "--auto", "--editor", "--modo-edicion", "--chat", "--web", "--web-puerto", "--demo",
+     ("--plan", "--auto", "--editor", "--modo-edicion", "--validar", "--no-validar-sintaxis", "--max-intentos-validacion",
+      "--chat", "--web", "--web-puerto", "--demo",
       "--init", "--init-claude", "--historial", "--historial-limpiar",
       "--diagnostico", "--reparar", "--bienvenida")),
     ("Selección de archivos",
@@ -7346,6 +7472,26 @@ def crear_parser() -> argparse.ArgumentParser:
              "'sobrescribir' (sobrescritura completa del archivo) o 'ast' "
              "(edición basada en el árbol sintáctico con fallback a sobrescritura).",
     )
+    parser.add_argument(
+        "--validar", dest="validar", action="store_const", const=True,
+        default=True,
+        help="Valida la sintaxis del código antes de guardar en el editor propio "
+             "(por defecto activado).",
+    )
+    parser.add_argument(
+        "--no-validar-sintaxis", dest="validar", action="store_const",
+        const=False,
+        help="Desactiva la validación de sintaxis en el editor propio "
+             "(comportamiento previo a v3.4.0). Nota: su nombre no es "
+             "'--no-validar' porque ese alias ya está reservado por "
+             "--iniciar-proyecto.",
+    )
+    parser.add_argument(
+        "--max-intentos-validacion", type=int,
+        default=MAX_INTENTOS_VALIDACION, metavar="N",
+        help=f"Intentos máximos de validación de sintaxis antes de cancelar la "
+             f"edición (por defecto: {MAX_INTENTOS_VALIDACION}).",
+    )
     # Aprendizaje autónomo / memoria avanzada (v3.0.0)
     parser.add_argument(
         "--daemon", action="store_true",

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_auto_017.py

@@ -183,7 +183,7 @@ class TestFlagsAutoCli(unittest.TestCase):
         self.assertTrue(args.plan)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_diagnostico_310.py

@@ -35,7 +35,7 @@ class TestFlagsCli310(unittest.TestCase):
                                                      ).bienvenida)
 
     def test_version_es_3_1_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 class TestApiKeyDetection(unittest.TestCase):

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_diff_editor_210.py

@@ -98,7 +98,7 @@ class TestFlagsEdicion(unittest.TestCase):
         self.assertEqual(parser.parse_args(["--modo-edicion", "sobrescribir", "c"]).modo_edicion, "sobrescribir")
 
     def test_version_es_2_1_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_editor_330.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""Tests del editor propio v3.3.0.
+"""Tests del editor propio v3.3.0 (base) — validado bajo v3.4.0.
 
 Cubre el refinamiento multi-lenguaje del AST, el manejo de conflictos en
 parches (validación previa, resolución incremental) y la integración con

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_editor_ast_220.py

@@ -174,7 +174,7 @@ class TestFlagsEdicionAST(unittest.TestCase):
         self.assertEqual(args2.modo_edicion, "auto")
 
     def test_version_es_2_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_editor_propio_200.py

@@ -84,7 +84,7 @@ class TestFlagsEditor(unittest.TestCase):
         self.assertIsInstance(orch.agente_editor_propio, AgenteEditorPropio)
 
     def test_version_es_2_0_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_exe_150.py

@@ -14,7 +14,7 @@ import snapcontext as sc  # noqa: E402
 
 class TestVersion(unittest.TestCase):
     def test_version_150_coherente(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 class TestEstaticoWeb(unittest.TestCase):

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_jetbrains_170.py

@@ -17,7 +17,7 @@ import snapcontext as sc  # noqa: E402
 
 class TestVersion(unittest.TestCase):
     def test_version_170_coherente(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 class TestEstructuraJetBrains(unittest.TestCase):

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_mcp_014.py

@@ -217,7 +217,7 @@ class TestFormatoYAutoContexto(BaseMCP):
 
 class TestVersionMCPCli(BaseMCP):
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_mcp_140.py

@@ -248,7 +248,7 @@ class TestChatComandosGrafo(unittest.TestCase):
 
 class TestVersion(unittest.TestCase):
     def test_version_140_coherente(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_memoria_015.py

@@ -179,7 +179,7 @@ class TestFlagsMemoriaCli(BaseMemoria):
             ["--init-claude"]).init_claude)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_memoria_300.py

@@ -312,7 +312,7 @@ class TestFlagsCLI(unittest.TestCase):
         self.assertEqual(args.daemon_intervalo, 24)
 
     def test_version_300(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_permisos_013.py

@@ -182,7 +182,7 @@ class TestFlagsConfirmarCLI(unittest.TestCase):
         self.assertFalse(self._parse(["--chat", "--no-confirmar"]).confirmar)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_plan_012.py

@@ -269,7 +269,7 @@ class TestFlagsPlanCLI(unittest.TestCase):
         self.assertIsNone(self._parse(["--plan", "x"]).branch)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_plan_mcp_230.py

@@ -210,7 +210,7 @@ class TestEjecutarToolExecuteCommand(unittest.TestCase):
 
 class TestVersionYFlags(unittest.TestCase):
     def test_version_230(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
     def test_flag_paralelo(self):
         args = sc.crear_parser().parse_args(["--plan", "t", "--paralelo", "3"])

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_v010.py

@@ -168,7 +168,7 @@ class TestFlagsCLI(unittest.TestCase):
         self.assertTrue(args.vista_previa)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 class TestComandosAgenteChat(unittest.TestCase):

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_validacion_130.py

@@ -126,7 +126,7 @@ class TestIniciarProyecto(unittest.TestCase):
 class TestVersion(unittest.TestCase):
     def test_version_130_coherente(self):
         import snapcontext as sc
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

snapcontext-3.4.0/tests/test_validacion_sintaxis_340.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests de la validación de sintaxis del Editor Propio (v3.4.0).
+
+Cubre ``_validar_sintaxis`` (con mocks de subprocess para distintos lenguajes),
+los flags ``--validar / --no-validar / --max-intentos-validacion``, el flujo de
+reintentos de ``_aplicar_modo_sobrescribir`` y la vista previa de parches.
+"""
+
+import subprocess
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+import snapcontext as sc
+from agentes import AgenteEditorPropio
+
+
+class BaseValidacion(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp(prefix="sc340_")
+        self.raiz = Path(self.tmp).resolve()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+
+def _proc(codigo, stderr="", stdout=""):
+    return SimpleNamespace(returncode=codigo, stderr=stderr, stdout=stdout)
+
+
+class TestValidarSintaxis(BaseValidacion):
+    """_validar_sintaxis con mocks de lenguaje y subprocess."""
+
+    def test_python_valido_devuelve_true(self):
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="python"), \
+                mock.patch("snapcontext.shutil.which", return_value="/a/python"), \
+                mock.patch("snapcontext.subprocess.run", return_value=_proc(0)) as run:
+            ok, mensaje = sc._validar_sintaxis("modulo.py", "def f(): pass\n", self.tmp)
+        self.assertTrue(ok)
+        self.assertEqual(mensaje, "")
+        cmd = run.call_args[0][0]
+        self.assertEqual(cmd[1:3], ["-m", "py_compile"])
+
+    def test_lenguaje_sin_validador_omite(self):
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="json"):
+            ok, mensaje = sc._validar_sintaxis("datos.json", "{}", self.tmp)
+        self.assertTrue(ok)
+        self.assertEqual(mensaje, "")
+
+    def test_comando_no_disponible_omite(self):
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="dart"), \
+                mock.patch("snapcontext.shutil.which", return_value=None), \
+                mock.patch("snapcontext.subprocess.run") as run:
+            ok, mensaje = sc._validar_sintaxis("app.dart", "void main(){}\n", self.tmp)
+        self.assertTrue(ok)
+        self.assertEqual(mensaje, "")
+        run.assert_not_called()
+
+    def test_dart_fallback_analyze_indisponible(self):
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="dart"), \
+                mock.patch("snapcontext.shutil.which",
+                           side_effect=lambda b: b if b == "dart" else None), \
+                mock.patch("snapcontext.subprocess.run",
+                           side_effect=[FileNotFoundError, _proc(0)]) as run:
+            ok, mensaje = sc._validar_sintaxis("lib/main.dart", "dart", self.tmp)
+        self.assertTrue(ok)
+        self.assertEqual(run.call_count, 2)
+        self.assertEqual(run.call_args_list[1][0][0][0:2],
+                         ["dart", "format"])
+
+    def test_timeout_devuelve_false(self):
+        exc = subprocess.TimeoutExpired("cmd", 60)
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="python"), \
+                mock.patch("snapcontext.shutil.which", return_value="/a/python"), \
+                mock.patch("snapcontext.subprocess.run", side_effect=exc):
+            ok, mensaje = sc._validar_sintaxis("modulo.py", "x = 1\n", self.tmp)
+        self.assertFalse(ok)
+        self.assertIn("tiempo", mensaje.lower())
+
+    def test_java_y_node_comandos(self):
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="java"), \
+                mock.patch("snapcontext.shutil.which", return_value="/a/javac"), \
+                mock.patch("snapcontext.subprocess.run", return_value=_proc(0)) as run:
+            ok, _ = sc._validar_sintaxis("Main.java", "class Main {}", self.tmp)
+        self.assertTrue(ok)
+        self.assertEqual(run.call_args[0][0][0], "javac")
+
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="javascript"), \
+                mock.patch("snapcontext.shutil.which", return_value="/a/node"), \
+                mock.patch("snapcontext.subprocess.run", return_value=_proc(0)) as run:
+            ok, _ = sc._validar_sintaxis("script.js", "const x = 1;", self.tmp)
+        self.assertTrue(ok)
+        self.assertEqual(run.call_args[0][0][0], "node")
+
+    def test_python_invalido_devuelve_false_y_mensaje(self):
+        with mock.patch.object(sc, "_lenguaje_archivo", return_value="python"), \
+                mock.patch("snapcontext.shutil.which", return_value="/a/python"), \
+                mock.patch("snapcontext.subprocess.run",
+                           return_value=_proc(1, stderr="SyntaxError: invalid syntax")):
+            ok, mensaje = sc._validar_sintaxis("modulo.py", "def (\n", self.tmp)
+        self.assertFalse(ok)
+        self.assertIn("SyntaxError", mensaje)
+class TestFlagsValidacion(unittest.TestCase):
+    def test_validar_por_defecto_true(self):
+        args = sc.crear_parser().parse_args(["consulta"])
+        self.assertTrue(args.validar)
+
+    def test_no_validar_sintaxis_false(self):
+        args = sc.crear_parser().parse_args(["consulta", "--no-validar-sintaxis"])
+        self.assertFalse(args.validar)
+
+    def test_validar_explicito_true(self):
+        args = sc.crear_parser().parse_args(["consulta", "--validar"])
+        self.assertTrue(args.validar)
+
+    def test_max_intentos_validacion_defecto_y_personalizado(self):
+        args = sc.crear_parser().parse_args(["consulta"])
+        self.assertEqual(args.max_intentos_validacion, 3)
+        args2 = sc.crear_parser().parse_args(
+            ["consulta", "--max-intentos-validacion", "5"])
+        self.assertEqual(args2.max_intentos_validacion, 5)
+class TestReintentosSobrescribir(BaseValidacion):
+    """Flujo de reintentos de validación en _aplicar_modo_sobrescribir."""
+
+    def test_falla_y_luego_aprueba(self):
+        agente = AgenteEditorPropio()
+        archivo = "modulo.py"
+        (self.raiz / archivo).write_text("def f(): return 1\n", encoding="utf-8")
+        with mock.patch.object(sc, "cargar_configuracion", return_value={}), \
+                mock.patch.object(sc, "_enviar_al_proveedor",
+                                  return_value="def f(): return 2\n") as enviar, \
+                mock.patch.object(sc, "_validar_sintaxis",
+                                  side_effect=[(False, "SyntaxError"), (True, "")]) as val, \
+                mock.patch.object(agente, "sobrescribir", return_value=True) as sob:
+            ok = agente._aplicar_modo_sobrescribir(
+                archivo, "cambiar retorno", "def f(): return 1\n",
+                modelo=None, directorio=str(self.raiz))
+        self.assertTrue(ok)
+        self.assertEqual(enviar.call_count, 2)   # 1ª generación + reintento
+        self.assertEqual(val.call_count, 2)
+        sob.assert_called_once_with(archivo, "def f(): return 2\n",
+                                    str(self.raiz))
+
+    def test_agota_intentos_cancela_sin_guardar(self):
+        agente = AgenteEditorPropio()
+        archivo = "modulo.py"
+        (self.raiz / archivo).write_text("x = 1\n", encoding="utf-8")
+        with mock.patch.object(sc, "cargar_configuracion", return_value={}), \
+                mock.patch.object(sc, "_enviar_al_proveedor",
+                                  return_value="malo()(") as enviar, \
+                mock.patch.object(sc, "_validar_sintaxis",
+                                  return_value=(False, "SyntaxError")) as val, \
+                mock.patch.object(agente, "sobrescribir") as sob:
+            ok = agente._aplicar_modo_sobrescribir(
+                archivo, "cambia", "x = 1\n", modelo=None,
+                directorio=self.tmp, max_intentos_validacion=3)
+        self.assertFalse(ok)
+        self.assertEqual(enviar.call_count, 3)
+        self.assertEqual(val.call_count, 3)
+        sob.assert_not_called()
+
+    def test_validar_false_no_valida(self):
+        agente = AgenteEditorPropio()
+        archivo = "modulo.py"
+        with mock.patch.object(sc, "cargar_configuracion", return_value={}), \
+                mock.patch.object(sc, "_enviar_al_proveedor",
+                                  return_value="x = 1\n") as enviar, \
+                mock.patch.object(sc, "_validar_sintaxis") as val, \
+                mock.patch.object(agente, "sobrescribir", return_value=True) as sob:
+            ok = agente._aplicar_modo_sobrescribir(
+                archivo, "cambiar", "", modelo=None, directorio=self.tmp,
+                validar=False)
+        self.assertTrue(ok)
+        self.assertEqual(enviar.call_count, 1)
+        val.assert_not_called()
+        sob.assert_called_once()
+
+
+class TestPreviewParche(BaseValidacion):
+    def test_preview_aplica_hunk(self):
+        agente = AgenteEditorPropio()
+        parche = ("--- a/modulo.py\n+++ b/modulo.py\n@@ -1 +1 @@\n"
+                  "-def fn(): return 1\n+def fn(): return 2\n")
+        resultado, aplicados = agente._aplicar_parche_preview(
+            parche, "def fn(): return 1\n")
+        self.assertEqual(aplicados, 1)
+        self.assertIn("def fn(): return 2", resultado)
+
+
+if __name__ == "__main__":
+    unittest.main()

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_vscode_016.py

@@ -91,7 +91,7 @@ class TestEstructuraVsCode(unittest.TestCase):
 
 class TestVersionCli(unittest.TestCase):
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.3.0 → snapcontext-3.4.0}/tests/test_web_160.py

@@ -17,7 +17,7 @@ INDEX = RAIZ / "web" / "static" / "index.html"
 
 class TestVersion(unittest.TestCase):
     def test_version_160_coherente(self):
-        self.assertEqual(sc.VERSION, "3.3.0")
+        self.assertEqual(sc.VERSION, "3.4.0")
 
 
 class TestFrontendV160(unittest.TestCase):