snapcontext 3.2.0__tar.gz → 3.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 3.2.0
+Version: 3.3.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -143,6 +143,18 @@ La extensión vive en `vscode/` y está escrita en TypeScript:
 - Empaquetar: `vscode/scripts/empaquetar.ps1` / `.sh` (compilan antes de
   ejecutar `vsce package`).
 
+### Editor propio refinado (v3.3.0)
+- **Detección de lenguaje robusta**: extensión + heurística por contenido
+  (shebang, patrones de código) para proyectos mixtos.
+- **Manejo de conflictos en parches**: validación previa del contenido del
+  archivo y resolución automática línea a línea si `git apply`/`patch`
+  fallan (con aviso de aplicación parcial); ya no se sobrescribe a ciegas.
+- **Prompt de edición mejorado**: lenguaje, tamaño, resumen AST con
+  posiciones y reglas de precisión (estilo conservado, cambios mínimos).
+- **Aprendizaje de patrones**: las ediciones exitosas se guardan como skills
+  (`editor-<patrón>`) y su estrategia se reutiliza automáticamente en
+  tareas similares.
+
 ## 🚀 Inicio rápido (5 minutos)
 
 ```bash

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

@@ -98,6 +98,18 @@ La extensión vive en `vscode/` y está escrita en TypeScript:
 - Empaquetar: `vscode/scripts/empaquetar.ps1` / `.sh` (compilan antes de
   ejecutar `vsce package`).
 
+### Editor propio refinado (v3.3.0)
+- **Detección de lenguaje robusta**: extensión + heurística por contenido
+  (shebang, patrones de código) para proyectos mixtos.
+- **Manejo de conflictos en parches**: validación previa del contenido del
+  archivo y resolución automática línea a línea si `git apply`/`patch`
+  fallan (con aviso de aplicación parcial); ya no se sobrescribe a ciegas.
+- **Prompt de edición mejorado**: lenguaje, tamaño, resumen AST con
+  posiciones y reglas de precisión (estilo conservado, cambios mínimos).
+- **Aprendizaje de patrones**: las ediciones exitosas se guardan como skills
+  (`editor-<patrón>`) y su estrategia se reutiliza automáticamente en
+  tareas similares.
+
 ## 🚀 Inicio rápido (5 minutos)
 
 ```bash

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

@@ -181,15 +181,22 @@ class AgenteEditorPropio:
         self,
         parche: str,
         directorio: str = ".",
+        contenido_esperado: Optional[str] = None,
     ) -> bool:
-        """Aplica un parche unificado en ``directorio``.
+        """Aplica un parche unificado en ``directorio`` (v3.3.0).
+
+        Con ``contenido_esperado`` se valida antes que el archivo coincida
+        con el usado para generar el parche y, si hay conflicto, se intenta
+        la resolución incremental línea a línea.
 
         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)
+        return sc._aplicar_parche_con_resolucion(
+            parche, directorio=directorio,
+            contenido_esperado=contenido_esperado)
 
     def _cadena_modos(self, archivo: str, mensaje: str,
                       modo_edicion: str) -> List[str]:
@@ -233,12 +240,21 @@ class AgenteEditorPropio:
 
         pref = sc.cargar_configuracion()
         proveedor = pref.get("provider") or sc.PROVEEDOR_DEFECTO
+        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 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"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}\n\n"
-            f"Contenido actual:\n```\n{contenido_actual}\n```\n\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(
@@ -250,7 +266,9 @@ class AgenteEditorPropio:
             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)
+            # v3.3.0: validación previa + resolución de conflictos.
+            return self.aplicar_parche(diff_limpio, directorio,
+                                       contenido_esperado=contenido_actual)
         return False
 
     def _aplicar_modo_sobrescribir(self, archivo: str, mensaje: str,
@@ -261,11 +279,13 @@ class AgenteEditorPropio:
 
         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 para cumplir con la tarea.\n\n"
+            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}\n\n"
-            f"Contenido actual:\n```\n{contenido_actual}\n```\n\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(
@@ -298,6 +318,18 @@ class AgenteEditorPropio:
         raiz = Path(directorio).resolve()
         todo_ok = True
 
+        # v3.3.0 — Integración con skills: si ya existe un patrón de edición
+        # aprendido para esta tarea, se prioriza su estrategia (sin pasar por
+        # el proveedor de IA cuando el skill lo permita).
+        estrategia_aprendida = None
+        try:
+            estrategia_aprendida = sc._skill_editor_estrategia(mensaje)
+            if estrategia_aprendida:
+                sc.info("[skills] Reutilizando patrón de edición aprendido: "
+                        f"'{estrategia_aprendida}'.")
+        except Exception as exc:
+            sc.depurar(f"[skills] Búsqueda de skill falló: {exc}")
+
         for arch in archivos:
             camino = (raiz / arch).resolve()
             contenido_actual = ""
@@ -309,6 +341,10 @@ class AgenteEditorPropio:
                     pass
 
             cadena = self._cadena_modos(arch, mensaje, modo_edicion)
+            # El skill aprendido se coloca el primero en la cadena.
+            if estrategia_aprendida and estrategia_aprendida in cadena:
+                cadena.remove(estrategia_aprendida)
+                cadena.insert(0, estrategia_aprendida)
             conseguido = False
             for estrategia in cadena:
                 try:
@@ -329,7 +365,18 @@ class AgenteEditorPropio:
                     conseguido = False
                 if conseguido:
                     break
-            if not conseguido:
+
+            if conseguido:
+                # v3.3.0 — Aprendizaje: guardar/reforzar el patrón de edición.
+                patron = sc._editor_clasificar_tarea(mensaje)
+                sid = sc._skill_editor_guardar(
+                    mensaje, arch, patron, estrategia=estrategia)
+                if sid is not None:
+                    try:
+                        sc._skill_registrar_exito(sid)
+                    except Exception as exc:
+                        sc.depurar(f"[skills] Refuerzo falló: {exc}")
+            else:
                 sc.error(f"[AgenteEditorPropio] No se pudo editar '{arch}'.")
                 todo_ok = False
 

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0"
+version = "3.3.0"
 description = "SnapContext: Asistente de IA con contexto automático para desarrollo"
 readme = "README.md"
 requires-python = ">=3.9"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 3.2.0
+Version: 3.3.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -143,6 +143,18 @@ La extensión vive en `vscode/` y está escrita en TypeScript:
 - Empaquetar: `vscode/scripts/empaquetar.ps1` / `.sh` (compilan antes de
   ejecutar `vsce package`).
 
+### Editor propio refinado (v3.3.0)
+- **Detección de lenguaje robusta**: extensión + heurística por contenido
+  (shebang, patrones de código) para proyectos mixtos.
+- **Manejo de conflictos en parches**: validación previa del contenido del
+  archivo y resolución automática línea a línea si `git apply`/`patch`
+  fallan (con aviso de aplicación parcial); ya no se sobrescribe a ciegas.
+- **Prompt de edición mejorado**: lenguaje, tamaño, resumen AST con
+  posiciones y reglas de precisión (estilo conservado, cambios mínimos).
+- **Aprendizaje de patrones**: las ediciones exitosas se guardan como skills
+  (`editor-<patrón>`) y su estrategia se reutiliza automáticamente en
+  tareas similares.
+
 ## 🚀 Inicio rápido (5 minutos)
 
 ```bash

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

@@ -17,6 +17,7 @@ tests/test_bienvenida_311.py
 tests/test_deteccion.py
 tests/test_diagnostico_310.py
 tests/test_diff_editor_210.py
+tests/test_editor_330.py
 tests/test_editor_ast_220.py
 tests/test_editor_propio_200.py
 tests/test_embeddings_110.py

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

@@ -111,7 +111,7 @@ except ImportError:  # pragma: no cover
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 
-VERSION = "3.2.0"
+VERSION = "3.3.0"
 
 # v3.1.0 — Claves de API reconocidas para el modo por defecto (offline).
 CLAVES_API_CONOCIDAS = (
@@ -1802,6 +1802,214 @@ def _aplicar_parche(parche: str, directorio: str = ".") -> bool:
             os.remove(temp_path)
         except OSError:
             pass
+
+
+# ---------------------------------------------------------------------------
+# Manejo de conflictos y aplicación incremental (v3.3.0)
+# ---------------------------------------------------------------------------
+def _ruta_del_parche(parche: str) -> Optional[str]:
+    """Extrae la ruta del archivo objetivo del encabezado del parche.
+
+    Acepta encabezados ``--- a/ruta`` / ``+++ b/ruta`` y variantes sin
+    prefijo. Devuelve None si no se encuentra.
+    """
+    for linea in (parche or "").splitlines():
+        if linea.startswith("+++ "):
+            ruta = linea[4:].strip().split("\t")[0]
+            if ruta.startswith("b/"):
+                ruta = ruta[2:]
+            return ruta or None
+        if linea.startswith("--- "):
+            candidata = linea[4:].strip().split("\t")[0]
+            if candidata.startswith("a/"):
+                candidata = candidata[2:]
+            if candidata and candidata not in ("/dev/null",):
+                return candidata
+    return None
+
+
+def _validar_parche_previo(parche: str, directorio: str,
+                           contenido_esperado: Optional[str]) -> tuple:
+    """Verifica que el archivo coincide con lo usado para generar el parche.
+
+    Evita conflictos por cambios concurrentes: si el contenido actual del
+    archivo difiere del que se pasó al proveedor, aplicar a ciegas corrompería
+    la edición. Devuelve ``(ok, detalle)``.
+    """
+    if contenido_esperado is None:
+        return True, "sin validación (no hay contenido de referencia)"
+    ruta = _ruta_del_parche(parche)
+    if not ruta:
+        return True, "parche sin encabezado reconocible; se omite la validación"
+    destino = Path(directorio or ".").resolve() / ruta
+    if not destino.is_file():
+        return False, f"el archivo '{ruta}' ya no existe"
+    try:
+        actual = destino.read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        return False, f"no se pudo leer '{ruta}': {exc}"
+    if actual != contenido_esperado:
+        return False, (f"'{ruta}' cambió desde que se generó el parche "
+                       "(posible cambio concurrente)")
+    return True, "el archivo coincide con la referencia"
+
+
+def _parsear_hunks(parche: str) -> List[tuple]:
+    """Divide un diff unificado en hunks ``(linea_inicio_original, cambios)``.
+
+    ``cambios`` es una lista de ``(marca, texto)`` con marca ' ', '-' o '+'.
+    Se omiten los hunks sin líneas modificadas. Devuelve [] si no hay ninguno.
+    """
+    hunks: List[tuple] = []
+    hunk_actual: Optional[List[tuple]] = None
+    inicio_orig = 0
+    for linea in (parche or "").splitlines(keepends=True):
+        texto = linea.rstrip("\r\n")
+        m = re.match(r"@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@", texto)
+        if m:
+            if hunk_actual:
+                hunks.append((inicio_orig, hunk_actual))
+            inicio_orig = int(m.group(1))
+            hunk_actual = []
+            continue
+        if hunk_actual is None:
+            continue                      # encabezados ---/+++/ruido
+        if texto.startswith("+"):
+            hunk_actual.append(("+", texto[1:]))
+        elif texto.startswith("-"):
+            hunk_actual.append(("-", texto[1:]))
+        else:
+            hunk_actual.append((" ", texto[1:] if texto else ""))
+    if hunk_actual:
+        hunks.append((inicio_orig, hunk_actual))
+    return [(i, l) for i, l in hunks if any(marca != " " for marca, _ in l)]
+
+
+def _aplicar_hunks_incremental(parche: str, directorio: str) -> bool:
+    """Resolución automática de conflictos: aplica el parche línea a línea.
+
+    Estrategia puramente Python (sin git/patch): para cada hunk busca el
+    bloque original con tolerancia a desfases (posiciones cercanas + búsqueda
+    difusa por contexto con difflib) y aplica solo las líneas modificadas.
+    Los hunks irresolubles se omiten con aviso; se escribe el resultado si al
+    menos un hunk se aplicó, siempre con copia de seguridad previa.
+
+    Devuelve True si se aplicó algún cambio.
+    """
+    ruta = _ruta_del_parche(parche)
+    if not ruta:
+        aviso("[EditorPropio] No se pudo deducir el archivo del parche.")
+        return False
+    destino = Path(directorio or ".").resolve() / ruta
+    if not destino.is_file():
+        aviso(f"[EditorPropio] El archivo del parche no existe: {ruta}")
+        return False
+    try:
+        original = destino.read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        error(f"[EditorPropio] No se pudo leer '{ruta}': {exc}")
+        return False
+
+    resultado = original.splitlines()
+    hunks = _parsear_hunks(parche)
+    if not hunks:
+        aviso("[EditorPropio] El parche no contiene hunks aplicables.")
+        return False
+
+    def _coincide(desde: int, bloque: List[tuple]) -> bool:
+        """True si ``resultado[desde:]`` encaja con las líneas no-'+'."""
+        idx = desde
+        for marca, texto in bloque:
+            if marca == "+":
+                continue
+            if idx >= len(resultado) or resultado[idx] != texto:
+                return False
+            idx += 1
+        return True
+
+    def _n_borrar(bloque: List[tuple]) -> int:
+        return sum(1 for marca, _ in bloque if marca != "+")
+
+    aplicados = 0
+    desplazamiento = 0                     # acumulado por hunks previos
+    for inicio_orig, cambios in hunks:
+        base = max(inicio_orig - 1 + desplazamiento, 0)
+        n_borrados = _n_borrar(cambios)
+
+        posicion = -1
+        # 1) Coincidencia exacta cerca de la posición declarada.
+        offsets = sorted({0, 1, -1, 2, -2, 3, -3, 5, -5, 10, -10, 20, -20})
+        for delta in offsets:
+            candidato = base + delta
+            if 0 <= candidato <= len(resultado) and \
+                    _coincide(candidato, cambios):
+                posicion = candidato
+                break
+        # 2) Búsqueda difusa por líneas de contexto con difflib.
+        if posicion < 0:
+            contexto_idx = [i for i, (m, _) in enumerate(cambios)
+                            if m == " " and _.strip()]
+            if contexto_idx:
+                primera_ctx = cambios[contexto_idx[0]][1].strip()
+                for idx_linea, linea in enumerate(resultado):
+                    if linea.strip() == primera_ctx:
+                        candidato = idx_linea - contexto_idx[0]
+                        if _coincide(max(candidato, 0), cambios):
+                            posicion = max(candidato, 0)
+                            break
+        if posicion < 0 or not _coincide(posicion, cambios):
+            aviso(f"[EditorPropio] Hunk en línea {inicio_orig} no aplicable; "
+                  "se omite (resolución automática).")
+            continue
+
+        nuevo_bloque = [texto for marca, texto in cambios if marca != "-"]
+        resultado[posicion:posicion + n_borrados] = nuevo_bloque
+        desplazamiento += len(nuevo_bloque) - n_borrados
+        aplicados += 1
+
+    if not aplicados:
+        aviso("[EditorPropio] Ningún hunk pudo aplicarse; archivo intacto.")
+        return False
+    if aplicados < len(hunks):
+        aviso(f"[EditorPropio] Aplicación parcial: {aplicados}/{len(hunks)} "
+              "hunks. Revisa el resultado antes de confirmar.")
+
+    exito(f"[EditorPropio] Parche aplicado con resolución incremental "
+          f"(línea a línea) sobre '{ruta}'.")
+    return _editor_sobrescribir(ruta, "\n".join(resultado) + "\n",
+                                directorio=directorio)
+
+
+def _aplicar_parche_con_resolucion(parche: str, directorio: str = ".",
+                                   contenido_esperado: Optional[str] = None
+                                   ) -> bool:
+    """Aplica un parche con validación previa y resolución de conflictos.
+
+    Flujo (v3.3.0):
+      1. Validación previa: si se pasa ``contenido_esperado`` (el contenido
+         usado para generar el parche), comprueba que el archivo actual
+         coincida para evitar conflictos concurrentes.
+      2. Intento estándar: ``git apply`` → ``patch -p1``.
+      3. Resolución automática: aplicación incremental línea a línea.
+      4. Si todo falla, avisa para resolución manual (ya no sobrescribe a
+         ciegas).
+    """
+    ok_validacion, detalle = _validar_parche_previo(
+        parche, directorio, contenido_esperado)
+    if not ok_validacion:
+        aviso(f"[EditorPropio] Validación previa fallida: {detalle}. "
+              "Se intentará la resolución automática.")
+    elif contenido_esperado is not None:
+        depurar(f"[EditorPropio] Validación previa OK: {detalle}")
+
+    if _aplicar_parche(parche, directorio=directorio):
+        return True
+    info("[EditorPropio] Conflicto detectado; probando resolución "
+         "incremental (línea a línea)...")
+    return _aplicar_hunks_incremental(parche, directorio)
+
+
+
 # ---------------------------------------------------------------------------
 # Editor propio (Fase 3 — Edición basada en AST)  — v2.2.0
 # ---------------------------------------------------------------------------
@@ -1873,8 +2081,8 @@ def _resumen_ast(contenido: str, ruta: str) -> dict:
     Devuelve un dict con ``ok``, ``motor``, ``lenguaje`` y una proyección simple
     (funciones/clases/imports/variables/llamadas). Nunca lanza excepciones.
     """
-    lenguaje = _lenguaje_tree_sitter(ruta) or ""
-    if _es_extension_python(ruta):
+    lenguaje = _lenguaje_archivo(ruta, contenido) or ""
+    if _es_extension_python(ruta) or lenguaje == "python":
         return _resumen_ast_python(contenido)
     if tree_sitter is not None and _ts_lang is not None and lenguaje:
         try:
@@ -2096,12 +2304,21 @@ def _editor_ast(archivo: str, tarea: str, directorio: str = ".",
         return False
 
     proveedor = proveedor or cargar_configuracion().get("provider") or PROVEEDOR_DEFECTO
+    lenguaje = resumen.get("lenguaje") or _lenguaje_archivo(ruta_posix,
+                                                            contenido) or "?"
+    num_lineas = contenido.count("\n") + 1
     prompt = (
-        f"Vas a modificar un archivo comprendiendo su estructura sintáctica (AST).\n\n"
+        f"Vas a modificar un archivo comprendiendo su estructura sintáctica "
+        f"(AST). Objetivo: precisión máxima y cambios mínimos.\n\n"
         f"Tarea: {tarea}\n"
-        f"Archivo: {ruta_posix}\n\n"
-        f"Resumen del AST:\n{_formatear_resumen_ast(resumen, ruta_posix)}\n\n"
-        f"Contenido actual:\n```\n{contenido}\n```\n\n"
+        f"Archivo: {ruta_posix}  (lenguaje: {lenguaje}, {num_lineas} líneas)\n\n"
+        f"Resumen del AST (símbolos disponibles y sus posiciones):\n"
+        f"{_formatear_resumen_ast(resumen, ruta_posix)}\n\n"
+        f"Contenido actual completo:\n```\n{contenido}\n```\n\n"
+        f"Reglas de edición:\n"
+        f"- Conserva el estilo existente (indentación, comillas, convenciones).\n"
+        f"- Modifica SOLO lo necesario para la tarea; no reorganices el resto.\n"
+        f"- Usa los símbolos del resumen del AST para anclar tus cambios.\n\n"
         f"Responde ÚNICAMENTE con una lista JSON de operaciones de edición, por ejemplo:\n"
         f'[{{"tipo": "renombrar", "nombre": "viejo", "nuevo": "nuevo"}}]\n'
         f'O, si prefieres devolver el código completo resultante:\n'
@@ -4684,6 +4901,92 @@ def _skill_obtener(skill_id: int) -> Optional[dict]:
     return skill
 
 
+# ─── Skills del editor propio: patrones de edición (v3.3.0) ────────────────
+_EDITOR_PATRONES = (
+    ("renombrar", re.compile(
+        r"\b(renombrar|rename|cambia(r| el nombre)( de| la)? (la )?(función|"
+        r"funcion|variable|clase|método|metodo))\b", re.IGNORECASE)),
+    ("añadir_import", re.compile(
+        r"\b(a[nñ]ad(i|ir)|importar|import|agregar)\s+(el\s+|la\s+)?"
+        r"(import|módulo|modulo|librería|libreria|paquete)\b", re.IGNORECASE)),
+    ("refactorizar_clase", re.compile(
+        r"\b(refactoriza(r)?|reestructura|rdivide|extraer\s+clase|"
+        r"reorganiza(r)?)\b.*\b(clase|class|módulo|modulo)\b", re.IGNORECASE)),
+    ("añadir_funcion", re.compile(
+        r"\b(a[nñ]ade?|a[nñ]adir|crear?|agrega(r)?)\s+(una?\s+)?"
+        r"(función|funcion|función nueva|nueva funci|nuevo m[ée]todo|"
+        r"m[ée]todo)\b", re.IGNORECASE)),
+    ("corregir_error", re.compile(
+        r"\b(arregla|r|corrige|fix|bug|error|fallo|excepci[oó]n)\b",
+        re.IGNORECASE)),
+)
+
+
+def _editor_clasificar_tarea(tarea: str) -> str:
+    """Clasifica una tarea de edición en un patrón conocido (v3.3.0).
+
+    Devuelve uno de: 'renombrar', 'añadir_import', 'refactorizar_clase',
+    'añadir_funcion', 'corregir_error' o 'general'.
+    """
+    texto = (tarea or "").strip()
+    if not texto:
+        return "general"
+    for patron, regex in _EDITOR_PATRONES:
+        if regex.search(texto):
+            return patron
+    return "general"
+
+
+def _skill_editor_guardar(tarea: str, archivo: str, patron: str,
+                          estrategia: str = "parche") -> Optional[int]:
+    """Guarda/actualiza un skill con el patrón de edición exitoso (v3.3.0).
+
+    Idempotente por nombre (`editor-<patrón>`): si ya existe se actualiza.
+    Nunca lanza excepciones (los errores de memoria solo avisan).
+    """
+    try:
+        return _skill_guardar(
+            nombre=f"editor-{patron}",
+            consulta=tarea or f"editar {archivo}",
+            pasos=[{
+                "descripcion": (f"Edición '{patron}' aplicada con éxito "
+                                f"sobre {archivo}"),
+                "accion": "editor_propio",
+                "estrategia": estrategia,
+            }],
+            contexto={"archivo": archivo, "patron": patron,
+                      "estrategia": estrategia},
+            descripcion=f"Patrón de edición del editor propio: {patron}")
+    except Exception as exc:                   # pragma: no cover
+        depurar(f"[skills-editor] No se pudo guardar el skill: {exc}")
+        return None
+
+
+def _skill_editor_estrategia(tarea: str, umbral: float = 0.6) -> Optional[str]:
+    """Busca un skill de edición previo y devuelve su estrategia (v3.3.0).
+
+    Permite que el editor propio aplique directamente la estrategia que ya
+    funcionó para tareas similares, sin pasar por el proveedor de IA.
+    Solo se aceptan skills de editor no archivados y con confiabilidad >= 0.6.
+    """
+    try:
+        skill = _skill_buscar(f"editor {(tarea or '').strip()}", umbral=umbral)
+    except Exception as exc:
+        depurar(f"[skills-editor] Búsqueda falló: {exc}")
+        return None
+    if not skill or not str(skill.get("nombre", "")).startswith("editor-"):
+        return None
+    if float(skill.get("confiabilidad") or 0) < 0.6:
+        return None
+    for paso in skill.get("pasos") or []:
+        estrategia = paso.get("estrategia")
+        if estrategia in ("parche", "sobrescribir", "ast"):
+            depurar(f"[skills-editor] Reutilizando estrategia "
+                    f"'{estrategia}' del skill #{skill.get('id')}.")
+            return estrategia
+    return None
+
+
 def _skill_listar(incluir_archivados: bool = False,
                   solo_confiables: bool = False) -> List[dict]:
     """Lista skills ordenados por confiabilidad descendente."""
@@ -5457,18 +5760,69 @@ def _lenguaje_tree_sitter(ruta: str) -> Optional[str]:
     """Adivina el nombre de gramática tree-sitter para ``ruta``."""
     extension = Path(ruta).suffix.lower().lstrip(".")
     mapa = {
-        "py": "python", "js": "javascript", "jsx": "javascript",
-        "mjs": "javascript", "ts": "typescript", "tsx": "tsx",
+        "py": "python", "pyi": "python", "js": "javascript", "jsx": "javascript",
+        "mjs": "javascript", "cjs": "javascript", "ts": "typescript",
+        "mts": "typescript", "cts": "typescript", "tsx": "tsx",
         "dart": "dart", "go": "go", "rs": "rust", "java": "java",
         "kt": "kotlin", "kts": "kotlin", "swift": "swift", "c": "c",
-        "h": "c", "cpp": "cpp", "cc": "cpp", "hpp": "cpp", "cs": "c_sharp",
-        "rb": "ruby", "php": "php", "sh": "bash", "bash": "bash",
+        "h": "c", "cpp": "cpp", "cc": "cpp", "cxx": "cpp", "hpp": "cpp",
+        "hh": "cpp", "hxx": "cpp", "cs": "c_sharp", "rb": "ruby",
+        "php": "php", "sh": "bash", "bash": "bash", "zsh": "bash",
         "json": "json", "yaml": "yaml", "yml": "yaml", "toml": "toml",
-        "html": "html", "css": "css", "md": "markdown",
+        "html": "html", "htm": "html", "css": "css", "scss": "css",
+        "md": "markdown", "scala": "scala", "lua": "lua", "sql": "sql",
+        "ex": "elixir", "exs": "elixir", "zig": "zig", "hs": "haskell",
+        "r": "r", "vue": "vue", "svelte": "svelte",
     }
     return mapa.get(extension)
 
 
+# ─── Detección de lenguaje por contenido (v3.3.0) ──────────────────────────
+_PATRONES_LENGUAJE_CONTENIDO = (
+    (re.compile(r"^#!.*\bpython\S*", re.MULTILINE), "python"),
+    (re.compile(r"^#!.*\b(bash|sh|zsh)\b", re.MULTILINE), "bash"),
+    (re.compile(r"^#!.*\bnode\b", re.MULTILINE), "javascript"),
+    (re.compile(r"^package\s+\w+", re.MULTILINE), "go"),
+    (re.compile(r"<\?php", re.IGNORECASE), "php"),
+    (re.compile(r"^\s*def\s+\w+\s*\(.*\)\s*:", re.MULTILINE), "python"),
+    (re.compile(r"\bfunc(?:tion)?\s+\w*\s*\(", re.MULTILINE), "javascript"),
+    (re.compile(r"^\s*(public|private)?\s*class\s+\w+", re.MULTILINE), "java"),
+    (re.compile(r"\bfn\s+\w+\s*\(", re.MULTILINE), "rust"),
+)
+
+
+def _detectar_lenguaje_contenido(contenido: str) -> Optional[str]:
+    """Intenta adivinar el lenguaje a partir del contenido del archivo.
+
+    Se usa como refuerzo cuando la extensión es ambigua o desconocida
+    (p. ej. scripts sin extensión, archivos generados, proyectos mixtos).
+    """
+    if not contenido:
+        return None
+    muestra = contenido[:4096]
+    for patron, lenguaje in _PATRONES_LENGUAJE_CONTENIDO:
+        if patron.search(muestra):
+            return lenguaje
+    return None
+
+
+def _lenguaje_archivo(ruta: str,
+                      contenido: Optional[str] = None) -> Optional[str]:
+    """Detecta el lenguaje de ``ruta`` combinando extensión y contenido.
+
+    Prioridad: extensión conocida → heurística de contenido → None.
+    Más robusto que la detección solo por extensión en proyectos mixtos.
+    """
+    por_extension = _lenguaje_tree_sitter(ruta)
+    if por_extension:
+        return por_extension
+    if contenido is None:
+        leido = _leer_archivo(ruta)
+        contenido = leido or ""
+    return _detectar_lenguaje_contenido(contenido)
+
+
+
 def _extraer_simbolos_ts(arbol, lenguaje: str) -> dict:
     """Recorre el árbol tree-sitter y extrae funciones/clases/imports/llamadas."""
     funciones: List[dict] = []

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 class TestApiKeyDetection(unittest.TestCase):

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

@@ -79,6 +79,8 @@ class TestDiffYParches(unittest.TestCase):
         codigo_completo = "def fn(): return 2\n"
 
         with mock.patch.object(sc, "_enviar_al_proveedor", side_effect=["no es un diff", codigo_completo]), \
+             mock.patch.object(sc, "_skill_editor_estrategia", return_value=None), \
+             mock.patch.object(sc, "_skill_editor_guardar", return_value=None), \
              mock.patch.object(agente, "sobrescribir", return_value=True) as sob_mock:
             ok = agente.ejecutar([archivo], "cambiar retorno a 2", directorio=str(self.raiz), modo_edicion="auto")
             self.assertTrue(ok)
@@ -96,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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

snapcontext-3.3.0/tests/test_editor_330.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests del editor propio v3.3.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
+el sistema de skills.
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import snapcontext as sc
+from agentes import AgenteEditorPropio
+
+
+class TestClasificacionTareas(unittest.TestCase):
+    """_editor_clasificar_tarea: patrones de edición reconocidos."""
+
+    def test_renombrar(self):
+        self.assertEqual(sc._editor_clasificar_tarea(
+            "renombrar la función calcular_total"), "renombrar")
+
+    def test_import(self):
+        self.assertEqual(sc._editor_clasificar_tarea(
+            "añadir import de typing"), "añadir_import")
+
+    def test_refactorizar(self):
+        self.assertEqual(sc._editor_clasificar_tarea(
+            "refactorizar la clase Carrito"), "refactorizar_clase")
+
+    def test_funcion_nueva(self):
+        self.assertEqual(sc._editor_clasificar_tarea(
+            "crear una función de validación"), "añadir_funcion")
+
+    def test_corregir_error(self):
+        self.assertEqual(sc._editor_clasificar_tarea(
+            "corrige el bug del checkout"), "corregir_error")
+
+    def test_general(self):
+        self.assertEqual(sc._editor_clasificar_tarea(
+            "mejorar rendimiento"), "general")
+        self.assertEqual(sc._editor_clasificar_tarea(""), "general")
+
+
+class TestDeteccionLenguaje(unittest.TestCase):
+    """Detección multi-lenguaje refinada (extensión + contenido)."""
+
+    def test_extensiones_nuevas(self):
+        self.assertEqual(sc._lenguaje_tree_sitter("a.mts"), "typescript")
+        self.assertEqual(sc._lenguaje_tree_sitter("a.cxx"), "cpp")
+        self.assertEqual(sc._lenguaje_tree_sitter("a.zsh"), "bash")
+
+    def test_por_contenido_shebang(self):
+        self.assertEqual(sc._detectar_lenguaje_contenido(
+            "#!/usr/bin/env python3\nprint(1)\n"), "python")
+        self.assertEqual(sc._detectar_lenguaje_contenido(
+            "#!/bin/bash\necho hola\n"), "bash")
+
+    def test_lenguaje_archivo_combina(self):
+        self.assertEqual(sc._lenguaje_archivo("script", "#!/bin/bash\n"),
+                         "bash")
+        self.assertEqual(sc._lenguaje_archivo("main.go"), "go")
+        self.assertIsNone(sc._lenguaje_archivo("datos.xyz", "contenido"))
+
+    def test_resumen_ast_python_sin_extension(self):
+        resumen = sc._resumen_ast("def hola():\n    pass\n", "sin_nombre")
+        self.assertTrue(resumen["ok"])
+        self.assertEqual(resumen["motor"], "ast")
+
+
+class TestRutaYValidacionParche(unittest.TestCase):
+    """Extracción de ruta del parche y validación previa."""
+
+    PARCH = ("--- a/modulo.py\n+++ b/modulo.py\n@@ -1 +1 @@\n-viejo\n+nuevo\n")
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp(prefix="sc330_")
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_ruta_del_parche(self):
+        self.assertEqual(sc._ruta_del_parche(self.PARCH), "modulo.py")
+        sin_prefijo = self.PARCH.replace("b/", "").replace("a/", "")
+        self.assertEqual(sc._ruta_del_parche(sin_prefijo), "modulo.py")
+        self.assertIsNone(sc._ruta_del_parche(""))
+        self.assertIsNone(sc._ruta_del_parche("sin encabezados"))
+
+    def test_validacion_sin_referencia_ok(self):
+        ok, _ = sc._validar_parche_previo(self.PARCH, self.tmp, None)
+        self.assertTrue(ok)
+
+    def test_validacion_coincide(self):
+        (Path(self.tmp) / "modulo.py").write_text("viejo\n", encoding="utf-8")
+        ok, _ = sc._validar_parche_previo(self.PARCH, self.tmp, "viejo\n")
+        self.assertTrue(ok)
+
+    def test_validacion_detecta_cambio_concurrente(self):
+        (Path(self.tmp) / "modulo.py").write_text("otra cosa\n",
+                                                  encoding="utf-8")
+        ok, detalle = sc._validar_parche_previo(self.PARCH, self.tmp,
+                                                "viejo\n")
+        self.assertFalse(ok)
+        self.assertIn("concurrente", detalle)
+
+    def test_validacion_archivo_inexistente(self):
+        ok, detalle = sc._validar_parche_previo(self.PARCH, self.tmp,
+                                                "viejo\n")
+        self.assertFalse(ok)
+        self.assertIn("no existe", detalle)
+
+
+class TestParsearHunks(unittest.TestCase):
+    def test_hunks_basicos(self):
+        parche = ("--- a/f.py\n+++ b/f.py\n"
+                  "@@ -1,3 +1,3 @@\n ctx\n-old\n+new\n ctx2\n")
+        hunks = sc._parsear_hunks(parche)
+        self.assertEqual(len(hunks), 1)
+        inicio, cambios = hunks[0]
+        self.assertEqual(inicio, 1)
+        self.assertEqual(cambios, [(" ", "ctx"), ("-", "old"),
+                                   ("+", "new"), (" ", "ctx2")])
+
+    def test_sin_hunks(self):
+        self.assertEqual(sc._parsear_hunks(""), [])
+        self.assertEqual(sc._parsear_hunks("--- a/f.py\n+++ b/f.py\n"), [])
+
+
+class TestAplicacionIncremental(unittest.TestCase):
+    """Resolución automática línea a línea sobre archivos reales."""
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp(prefix="sc330inc_")
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def _escribir(self, nombre: str, contenido: str) -> str:
+        (Path(self.tmp) / nombre).write_text(contenido, encoding="utf-8")
+        return nombre
+
+    def test_aplica_parche_limpio_linea_a_linea(self):
+        original = "linea 1\nlinea 2\nlinea 3\nlinea 4\nlinea 5\n"
+        nuevo = "linea 1\nlinea DOS\nlinea 3\nlinea CUATRO\nlinea 5\n"
+        nombre = self._escribir("f.py", original)
+        parche = sc._generar_parche(original, nuevo, nombre)
+        self.assertTrue(sc._aplicar_hunks_incremental(parche, self.tmp))
+        resultado = (Path(self.tmp) / nombre).read_text(encoding="utf-8")
+        self.assertEqual(resultado, nuevo)
+
+    def test_aplica_con_desfase_de_lineas(self):
+        # El archivo tiene 2 líneas extra al principio: git apply fallaría,
+        # pero la resolución incremental encuentra el bloque por desfase.
+        original = "linea 1\nlinea 2\nlinea 3\nlinea 4\nlinea 5\n"
+        nuevo = "linea 1\nlinea 2\nlinea 3\nlinea CUATRO\nlinea 5\n"
+        nombre = self._escribir("g.py",
+                                "extra A\nextra B\n" + original)
+        parche = sc._generar_parche(original, nuevo, nombre)
+        self.assertTrue(sc._aplicar_hunks_incremental(parche, self.tmp))
+        resultado = (Path(self.tmp) / nombre).read_text(encoding="utf-8")
+        self.assertEqual(
+            resultado,
+            "extra A\nextra B\nlinea 1\nlinea 2\nlinea 3\n"
+            "linea CUATRO\nlinea 5\n")
+
+    def test_falla_si_nada_coincide(self):
+        self._escribir("h.py", "totalmente distinto\notra cosa\n")
+        parche = ("--- a/h.py\n+++ b/h.py\n@@ -1 +1 @@\n-viejo\n+nuevo\n")
+        self.assertFalse(sc._aplicar_hunks_incremental(parche, self.tmp))
+
+
+class TestResolucionConConflictos(unittest.TestCase):
+    """_aplicar_parche_con_resolucion: flujo completo de resolución."""
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp(prefix="sc330res_")
+        self.parche = ("--- a/m.py\n+++ b/m.py\n@@ -1 +1 @@\n-viejo\n+nuevo\n")
+        (Path(self.tmp) / "m.py").write_text("viejo\n", encoding="utf-8")
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_git_apply_exitoso_no_requiere_resolucion(self):
+        with mock.patch.object(sc, "_aplicar_parche", return_value=True), \
+                mock.patch.object(sc, "_aplicar_hunks_incremental") as inc:
+            self.assertTrue(sc._aplicar_parche_con_resolucion(
+                self.parche, self.tmp))
+            inc.assert_not_called()
+
+    def test_conflicto_cae_a_resolucion_incremental(self):
+        with mock.patch.object(sc, "_aplicar_parche", return_value=False), \
+                mock.patch.object(sc, "_aplicar_hunks_incremental",
+                                  return_value=True) as inc:
+            self.assertTrue(sc._aplicar_parche_con_resolucion(
+                self.parche, self.tmp))
+            inc.assert_called_once_with(self.parche, self.tmp)
+
+    def test_validacion_previa_avisa_pero_intenta(self):
+        # Contenido esperado distinto del actual → aviso y reintento igual.
+        with mock.patch.object(sc, "_aplicar_parche", return_value=True), \
+                mock.patch.object(sc, "aviso") as avisos:
+            ok = sc._aplicar_parche_con_resolucion(
+                self.parche, self.tmp, contenido_esperado="otro\n")
+            self.assertTrue(ok)
+            self.assertTrue(any("Validación previa fallida" in str(c.args[0])
+                                for c in avisos.call_args_list))
+
+
+class TestSkillsEditor(unittest.TestCase):
+    """Integración del editor propio con el sistema de skills."""
+
+    def test_guardar_skill_editor_usa_nombre_idempotente(self):
+        with mock.patch.object(sc, "_skill_guardar",
+                               return_value=42) as guardar:
+            sid = sc._skill_editor_guardar("renombrar la función x",
+                                           "modulo.py", "renombrar",
+                                           estrategia="ast")
+        self.assertEqual(sid, 42)
+        kwargs = guardar.call_args.kwargs
+        self.assertEqual(kwargs["nombre"], "editor-renombrar")
+        self.assertEqual(kwargs["pasos"][0]["estrategia"], "ast")
+        self.assertEqual(kwargs["contexto"]["archivo"], "modulo.py")
+
+    def test_guardar_skill_nunca_lanza(self):
+        with mock.patch.object(sc, "_skill_guardar",
+                               side_effect=RuntimeError("db rota")):
+            self.assertIsNone(sc._skill_editor_guardar("t", "a.py", "general"))
+
+    def test_estrategia_desde_skill_valido(self):
+        skill = {"id": 7, "nombre": "editor-renombrar",
+                 "confiabilidad": 0.8,
+                 "pasos": [{"accion": "editor_propio",
+                            "estrategia": "parche"}]}
+        with mock.patch.object(sc, "_skill_buscar", return_value=skill):
+            self.assertEqual(
+                sc._skill_editor_estrategia("renombrar la función y"),
+                "parche")
+
+    def test_ignora_skills_que_no_son_del_editor(self):
+        skill = {"id": 1, "nombre": "tarea-cualquiera", "confiabilidad": 1.0,
+                 "pasos": [{"estrategia": "parche"}]}
+        with mock.patch.object(sc, "_skill_buscar", return_value=skill):
+            self.assertIsNone(sc._skill_editor_estrategia("lo que sea"))
+
+    def test_ignora_baja_confiabilidad(self):
+        skill = {"id": 2, "nombre": "editor-general",
+                 "confiabilidad": 0.3,
+                 "pasos": [{"estrategia": "sobrescribir"}]}
+        with mock.patch.object(sc, "_skill_buscar", return_value=skill):
+            self.assertIsNone(sc._skill_editor_estrategia("lo que sea"))
+
+
+class TestIntegracionSkillsEnEjecutar(unittest.TestCase):
+    """AgenteEditorPropio.ejecutar reutiliza skills y guarda el patrón."""
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp(prefix="sc330skills_")
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_exito_guarda_patron_y_refuerza(self):
+        agente = AgenteEditorPropio()
+        archivo = "modulo.py"
+        (Path(self.tmp) / archivo).write_text("def fn(): return 1\n",
+                                              encoding="utf-8")
+        diff = ("--- a/modulo.py\n+++ b/modulo.py\n@@ -1 +1 @@\n"
+                "-def fn(): return 1\n+def fn(): return 2\n")
+        with mock.patch.object(sc, "_enviar_al_proveedor",
+                               return_value=diff), \
+                mock.patch.object(agente, "aplicar_parche", return_value=True), \
+                mock.patch.object(sc, "_skill_editor_estrategia",
+                                  return_value=None) as buscar, \
+                mock.patch.object(sc, "_skill_editor_guardar",
+                                  return_value=9) as guardar, \
+                mock.patch.object(sc, "_skill_registrar_exito",
+                                  return_value=0.65) as reforzar:
+            ok = agente.ejecutar([archivo], "corrige el retorno",
+                                 directorio=self.tmp, modo_edicion="parche")
+            self.assertTrue(ok)
+            buscar.assert_called_once()
+            guardar.assert_called_once()
+            args, _kwargs = guardar.call_args
+            self.assertEqual(args[2], "corregir_error")   # patrón clasificado
+            reforzar.assert_called_once_with(9)
+
+    def test_skill_aprendido_prioriza_estrategia(self):
+        agente = AgenteEditorPropio()
+        archivo = "modulo.py"
+        (Path(self.tmp) / archivo).write_text("x\n", encoding="utf-8")
+        with mock.patch.object(agente, "_cadena_modos",
+                               return_value=["parche", "sobrescribir"]), \
+                mock.patch.object(sc, "_skill_editor_estrategia",
+                                  return_value="sobrescribir"), \
+                mock.patch.object(sc, "_skill_editor_guardar",
+                                  return_value=None), \
+                mock.patch.object(agente, "_aplicar_modo_sobrescribir",
+                                  return_value=True) as sob, \
+                mock.patch.object(agente, "_aplicar_modo_parche") as parche:
+            ok = agente.ejecutar([archivo], "cambia algo",
+                                 directorio=self.tmp, modo_edicion="auto")
+            self.assertTrue(ok)
+            # La estrategia aprendida ('sobrescribir') se ejecutó primero.
+            sob.assert_called_once()
+            parche.assert_not_called()
+
+
+class TestPromptEditacionEnriquecido(unittest.TestCase):
+    """El prompt de parche incluye lenguaje, tamaño e instrucciones."""
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp(prefix="sc330prompt_")
+
+    def tearDown(self):
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_prompt_parche_contiene_lenguaje_e_instrucciones(self):
+        agente = AgenteEditorPropio()
+        diff = ("--- a/modulo.py\n+++ b/modulo.py\n@@ -1 +1 @@\n"
+                "-def fn(): return 1\n+def fn(): return 2\n")
+        with mock.patch.object(sc, "_enviar_al_proveedor",
+                               return_value=diff) as enviar, \
+                mock.patch.object(agente, "aplicar_parche", return_value=True):
+            agente._aplicar_modo_parche(
+                "modulo.py", "cambiar retorno a 2",
+                contenido_actual="def fn(): return 1\n",
+                modelo=None, directorio=self.tmp)
+        prompt = enviar.call_args[0][2][0]["content"]
+        self.assertIn("lenguaje: python", prompt)
+        self.assertIn("Instrucciones:", prompt)
+        self.assertIn("Conserva el estilo existente", prompt)
+        self.assertIn("```python", prompt)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 class TestEstaticoWeb(unittest.TestCase):

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 class TestEstructuraJetBrains(unittest.TestCase):

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
     def test_flag_paralelo(self):
         args = sc.crear_parser().parse_args(["--plan", "t", "--paralelo", "3"])

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 class TestComandosAgenteChat(unittest.TestCase):

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-3.2.0 → snapcontext-3.3.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.2.0")
+        self.assertEqual(sc.VERSION, "3.3.0")
 
 
 class TestFrontendV160(unittest.TestCase):