snapcontext 4.0.0__tar.gz → 4.2.0__tar.gz

{snapcontext-4.0.0/snapcontext.egg-info → snapcontext-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 4.0.0
+Version: 4.2.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -45,7 +45,7 @@ Dynamic: license-file
 
 # SnapContext
 
-![v4.0.0](https://img.shields.io/badge/version-4.0.0-blue.svg)
+![v4.2.0](https://img.shields.io/badge/version-4.2.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)
@@ -178,7 +178,7 @@ carpetas, extensiones y comandos de test por defecto.
 
 SnapContext incluye su propio editor integrado con soporte de parches unificados
 y edición basada en AST (Árbol Sintáctico) para refactorizaciones precisas:
-- **`--editor propio`**: Aplica cambios directamente y crea copias de seguridad automáticas en `~/.snapcontext/backups/`.
+- **`--editor propio`** (por defecto desde v4.1.0): Aplica cambios directamente y crea copias de seguridad automáticas en `~/.snapcontext/backups/`.
 - **`--modo-edicion {auto,parche,sobrescribir,ast}`**:
   - `auto` (por defecto): Genera un parche unificado (`git apply` / `patch`), pero
     para refactorizaciones estructurales intenta primero la edición **AST** y cae a
@@ -188,7 +188,35 @@ y edición basada en AST (Árbol Sintáctico) para refactorizaciones precisas:
     símbolos, insertar imports y recibir el código completo resultante.
   - `parche`: Fuerza la aplicación de parches unificados para ediciones precisas.
   - `sobrescribir`: Sobrescribe el archivo completo.
-- **`--editor aider`** (por defecto): Mantiene el flujo de edición con Aider para máxima compatibilidad.
+- **`--editor aider`**: Mantiene el flujo de edición con Aider para máxima compatibilidad.
+
+### Editor propio (modo por defecto desde v4.1.0)
+
+Desde la v4.1.0, **el editor propio es el modo por defecto**, reduciendo la
+dependencia de Aider sin eliminarla (`--editor aider` sigue disponible).
+
+**Cadena de auto-reparación**: para cada archivo se intentan las estrategias en
+orden — **AST → Parche → Sobrescritura** — informando cuál está en uso:
+
+```
+ℹ Editor propio: usando estrategia AST para 'modulo.py'...
+ℹ Editor propio: usando estrategia PARCHE para 'modulo.py'...
+```
+
+Si todas fallan, verás un error claro con las estrategias intentadas, el motivo
+y la sugerencia de probar con `--editor aider`. El fallo queda registrado en
+`~/.snapcontext/logs/editor_fallos.log` para depuración.
+
+**Resolución interactiva de conflictos**: si un parche no se aplica limpiamente,
+se ofrece elegir entre `[a]plicar de todas formas`, `[v]er el diff`,
+`[r]eintentar con el proveedor de IA` o `[c]ancelar conservando el original`.
+En modo `--auto` no se pregunta: se salta automáticamente a la siguiente
+estrategia. Funciona igual desde la CLI que desde `--chat`.
+
+**Optimizado para modelos locales (Ollama)**: si el proveedor es Ollama, el
+editor usa automáticamente **prompts concisos** en sus tres estrategias (menos
+contexto e instrucciones directas). También puedes forzarlos en cualquier
+proveedor con `--modelo-ligero` si sabes que usas un modelo pequeño.
 
 ```bash
 # Edición precisa mediante diffs unificados
@@ -274,6 +302,46 @@ El asesor también está disponible:
   cada sugerencia se presenta para aceptarla o rechazarla individualmente.
 - **En la web**: acción *Asesor* que muestra las sugerencias en un panel.
 
+### 🛡️ Seguridad y rendimiento en el asesor (v4.2.0)
+
+Con el nuevo flag `--asesor-profundo`, el asesor añade dos análisis extra a
+las heurísticas básicas de siempre:
+
+```bash
+snapcontext --asesor-profundo          # heurísticas + seguridad 🔒 + rendimiento ⚡
+snapcontext --asesor                   # solo heurísticas básicas (como v3.5.0)
+```
+
+**🔒 Vulnerabilidades detectadas** (heurísticas propias, sin dependencias
+externas como bandit):
+
+| Vulnerabilidad | Ejemplo |
+|---|---|
+| Inyección SQL | `"SELECT ... WHERE id = " + user_id` |
+| Command injection | `os.system("ping " + ip)`, `subprocess(..., shell=True)` |
+| Path traversal | `open("../" + filename)` |
+| Hardcoded secrets | `API_KEY = "sk-..."` en el código |
+| eval/exec inseguros | `eval(user_input)` |
+| XSS | `elemento.innerHTML = entrada` |
+
+**⚡ Rendimiento**: bucles anidados O(n²), `range(len(...))`, concatenación de
+cadenas con `+=` dentro de bucles, consultas N+1 del ORM y lectura completa de
+archivos grandes en memoria.
+
+Cada hallazgo incluye descripción, `archivo:línea`, solución propuesta y
+prioridad, integrado con el resto de sugerencias del asesor.
+
+También disponibles por separado:
+
+```bash
+# En el chat
+snapcontext --chat     # luego: /seguridad  ·  /rendimiento
+
+# En el planificador
+{"accion": "seguridad", "descripcion": "auditar el módulo de pagos"}
+{"accion": "rendimiento", "descripcion": "optimizar consultas"}
+```
+
 ### 🔌 API pública (v3.6.0)
 
 SnapContext expone una **API REST** para interactuar de forma programática
@@ -392,7 +460,9 @@ Sin plugins instalados, SnapContext funciona exactamente igual que siempre.
 | Modo | Comando |
 |------|---------|
 | Tarea | `snapcontext "<consulta>"` (+ `--test-loop`) |
-| Editor propio | `--editor propio` (con backups automáticos) |
+| Editor propio | `--editor propio` (por defecto desde v4.1.0, con backups automáticos) |
+| Aider (opcional) | `--editor aider` (flujo clásico con Aider) |
+| Prompts para modelos pequeños | `--modelo-ligero` (automático con Ollama) |
 | Vista previa / revisión | `--vista-previa` · alias `review` |
 | Chat interactivo | `--chat` |
 | Planificador | `--plan "<tarea>"` |

{snapcontext-4.0.0 → snapcontext-4.2.0}/README.md

@@ -1,6 +1,6 @@
 # SnapContext
 
-![v4.0.0](https://img.shields.io/badge/version-4.0.0-blue.svg)
+![v4.2.0](https://img.shields.io/badge/version-4.2.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)
@@ -133,7 +133,7 @@ carpetas, extensiones y comandos de test por defecto.
 
 SnapContext incluye su propio editor integrado con soporte de parches unificados
 y edición basada en AST (Árbol Sintáctico) para refactorizaciones precisas:
-- **`--editor propio`**: Aplica cambios directamente y crea copias de seguridad automáticas en `~/.snapcontext/backups/`.
+- **`--editor propio`** (por defecto desde v4.1.0): Aplica cambios directamente y crea copias de seguridad automáticas en `~/.snapcontext/backups/`.
 - **`--modo-edicion {auto,parche,sobrescribir,ast}`**:
   - `auto` (por defecto): Genera un parche unificado (`git apply` / `patch`), pero
     para refactorizaciones estructurales intenta primero la edición **AST** y cae a
@@ -143,7 +143,35 @@ y edición basada en AST (Árbol Sintáctico) para refactorizaciones precisas:
     símbolos, insertar imports y recibir el código completo resultante.
   - `parche`: Fuerza la aplicación de parches unificados para ediciones precisas.
   - `sobrescribir`: Sobrescribe el archivo completo.
-- **`--editor aider`** (por defecto): Mantiene el flujo de edición con Aider para máxima compatibilidad.
+- **`--editor aider`**: Mantiene el flujo de edición con Aider para máxima compatibilidad.
+
+### Editor propio (modo por defecto desde v4.1.0)
+
+Desde la v4.1.0, **el editor propio es el modo por defecto**, reduciendo la
+dependencia de Aider sin eliminarla (`--editor aider` sigue disponible).
+
+**Cadena de auto-reparación**: para cada archivo se intentan las estrategias en
+orden — **AST → Parche → Sobrescritura** — informando cuál está en uso:
+
+```
+ℹ Editor propio: usando estrategia AST para 'modulo.py'...
+ℹ Editor propio: usando estrategia PARCHE para 'modulo.py'...
+```
+
+Si todas fallan, verás un error claro con las estrategias intentadas, el motivo
+y la sugerencia de probar con `--editor aider`. El fallo queda registrado en
+`~/.snapcontext/logs/editor_fallos.log` para depuración.
+
+**Resolución interactiva de conflictos**: si un parche no se aplica limpiamente,
+se ofrece elegir entre `[a]plicar de todas formas`, `[v]er el diff`,
+`[r]eintentar con el proveedor de IA` o `[c]ancelar conservando el original`.
+En modo `--auto` no se pregunta: se salta automáticamente a la siguiente
+estrategia. Funciona igual desde la CLI que desde `--chat`.
+
+**Optimizado para modelos locales (Ollama)**: si el proveedor es Ollama, el
+editor usa automáticamente **prompts concisos** en sus tres estrategias (menos
+contexto e instrucciones directas). También puedes forzarlos en cualquier
+proveedor con `--modelo-ligero` si sabes que usas un modelo pequeño.
 
 ```bash
 # Edición precisa mediante diffs unificados
@@ -229,6 +257,46 @@ El asesor también está disponible:
   cada sugerencia se presenta para aceptarla o rechazarla individualmente.
 - **En la web**: acción *Asesor* que muestra las sugerencias en un panel.
 
+### 🛡️ Seguridad y rendimiento en el asesor (v4.2.0)
+
+Con el nuevo flag `--asesor-profundo`, el asesor añade dos análisis extra a
+las heurísticas básicas de siempre:
+
+```bash
+snapcontext --asesor-profundo          # heurísticas + seguridad 🔒 + rendimiento ⚡
+snapcontext --asesor                   # solo heurísticas básicas (como v3.5.0)
+```
+
+**🔒 Vulnerabilidades detectadas** (heurísticas propias, sin dependencias
+externas como bandit):
+
+| Vulnerabilidad | Ejemplo |
+|---|---|
+| Inyección SQL | `"SELECT ... WHERE id = " + user_id` |
+| Command injection | `os.system("ping " + ip)`, `subprocess(..., shell=True)` |
+| Path traversal | `open("../" + filename)` |
+| Hardcoded secrets | `API_KEY = "sk-..."` en el código |
+| eval/exec inseguros | `eval(user_input)` |
+| XSS | `elemento.innerHTML = entrada` |
+
+**⚡ Rendimiento**: bucles anidados O(n²), `range(len(...))`, concatenación de
+cadenas con `+=` dentro de bucles, consultas N+1 del ORM y lectura completa de
+archivos grandes en memoria.
+
+Cada hallazgo incluye descripción, `archivo:línea`, solución propuesta y
+prioridad, integrado con el resto de sugerencias del asesor.
+
+También disponibles por separado:
+
+```bash
+# En el chat
+snapcontext --chat     # luego: /seguridad  ·  /rendimiento
+
+# En el planificador
+{"accion": "seguridad", "descripcion": "auditar el módulo de pagos"}
+{"accion": "rendimiento", "descripcion": "optimizar consultas"}
+```
+
 ### 🔌 API pública (v3.6.0)
 
 SnapContext expone una **API REST** para interactuar de forma programática
@@ -347,7 +415,9 @@ Sin plugins instalados, SnapContext funciona exactamente igual que siempre.
 | Modo | Comando |
 |------|---------|
 | Tarea | `snapcontext "<consulta>"` (+ `--test-loop`) |
-| Editor propio | `--editor propio` (con backups automáticos) |
+| Editor propio | `--editor propio` (por defecto desde v4.1.0, con backups automáticos) |
+| Aider (opcional) | `--editor aider` (flujo clásico con Aider) |
+| Prompts para modelos pequeños | `--modelo-ligero` (automático con Ollama) |
 | Vista previa / revisión | `--vista-previa` · alias `review` |
 | Chat interactivo | `--chat` |
 | Planificador | `--plan "<tarea>"` |

{snapcontext-4.0.0 → snapcontext-4.2.0}/agentes.py

@@ -150,6 +150,27 @@ class AgenteEditor:
         return sc.ejecutar_aider(archivos, mensaje, directorio, opciones)
 
 
+def _prompts_concisos(proveedor: Optional[str],
+                      modelo_ligero: bool = False) -> bool:
+    """v4.1.0: ¿usar prompts concisos? Con Ollama o ``--modelo-ligero``."""
+    if modelo_ligero:
+        return True
+    return str(proveedor or "").strip().lower() == "ollama"
+
+
+def _proveedor_efectivo(proveedor: Optional[str]) -> str:
+    """Resuelve el proveedor: explícito → config.json → defecto."""
+    import snapcontext as sc
+
+    if proveedor:
+        return proveedor
+    try:
+        return sc.cargar_configuracion().get("provider") or \
+            sc.PROVEEDOR_DEFECTO
+    except Exception:
+        return sc.PROVEEDOR_DEFECTO
+
+
 class AgenteEditorPropio:
     """Agente Editor Propio: editor integrado de SnapContext.
 
@@ -222,7 +243,8 @@ class AgenteEditorPropio:
         return ["parche", "sobrescribir"]
 
     def editar_ast(self, archivo: str, tarea: str,
-                   directorio: str = ".", modelo: Optional[str] = None) -> bool:
+                   directorio: str = ".", modelo: Optional[str] = None,
+                   conciso: bool = False) -> bool:
         """Edita ``archivo`` con base en su AST usando el proveedor de IA."""
         import snapcontext as sc
 
@@ -230,7 +252,8 @@ class AgenteEditorPropio:
         proveedor = pref.get("provider") or sc.PROVEEDOR_DEFECTO
         sc.depurar(f"[AgenteEditorPropio] Editando por AST '{archivo}' en '{directorio}'")
         return sc._editor_ast(archivo, tarea, directorio=directorio,
-                              proveedor=proveedor, modelo=modelo)
+                              proveedor=proveedor, modelo=modelo,
+                              conciso=conciso)
 
     @staticmethod
     def _aplicar_parche_preview(parche: str, contenido_actual: str):
@@ -280,7 +303,9 @@ class AgenteEditorPropio:
     def _aplicar_modo_parche(self, archivo: str, mensaje: str,
                              contenido_actual: str, modelo: Optional[str],
                              directorio: str, validar: bool = True,
-                             max_intentos_validacion: int = 3) -> bool:
+                             max_intentos_validacion: int = 3,
+                             conciso: bool = False,
+                             auto: bool = False) -> bool:
         """Intenta editar `archivo` pidiendo un parche unificado al proveedor."""
         import snapcontext as sc
 
@@ -293,28 +318,38 @@ class AgenteEditorPropio:
 
         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 conciso:
+                # v4.1.0: variante reducida para modelos ligeros (Ollama).
+                prompt = (
+                    f"Tarea: {mensaje}\n"
+                    f"Archivo: {archivo} ({lenguaje}, {num_lineas} líneas)\n\n"
+                    f"```\n{contenido_actual}\n```\n\n"
+                    f"Responde SOLO el diff unificado (--- a/… +++ b/… con @@)."
+                )
+            else:
+                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."
-            )
+            if not conciso:
+                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
@@ -329,40 +364,94 @@ class AgenteEditorPropio:
 
             if not validar:
                 # v3.3.0: validación previa + resolución de conflictos.
-                return self.aplicar_parche(diff_limpio, directorio,
-                                           contenido_esperado=contenido_actual)
+                return self._aplicar_con_conflicto(
+                    archivo, diff_limpio, directorio, contenido_actual,
+                    preview=None, auto=auto) == "ok"
 
             # 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)
+                return self._aplicar_con_conflicto(
+                    archivo, diff_limpio, directorio, contenido_actual,
+                    preview=None, auto=auto) == "ok"
 
             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:
+            if not exito:
+                error_msj = err
+                if intento < max_val:
+                    sc.error(
+                        f"Error de sintaxis: {err}. "
+                        f"Reintentando ({intento}/{max_val})...")
+                    continue
                 sc.error(
                     f"No se pudo validar tras {max_val} intentos. "
                     f"Edición cancelada.")
                 return False
+            sc.exito("Sintaxis válida.")
+            resultado = self._aplicar_con_conflicto(
+                archivo, diff_limpio, directorio, contenido_actual,
+                preview=preview, auto=auto)
+            if resultado == "ok":
+                return True
+            if resultado == "cancelar":
+                return False
+            # "reintentar": el usuario pidió reintentar con el proveedor.
+            error_msj = ("el parche no se aplicó limpiamente; "
+                         "genera un diff corregido y completo")
+            if intento >= max_val:
+                return False
+            sc.info(f"Reintentando parche ({intento}/{max_val})...")
         return False
 
+    def _aplicar_con_conflicto(self, archivo: str, diff: str,
+                               directorio: str, contenido_actual: str,
+                               preview: Optional[str] = None,
+                               auto: bool = False) -> str:
+        """Aplica el parche resolviendo conflictos de forma interactiva.
+
+        Devuelve ``"ok"``, ``"reintentar"`` o ``"cancelar"``.
+        En modo ``--auto`` no pregunta: devuelve el resultado directo para que
+        ``ejecutar()`` pase a la siguiente estrategia.
+        """
+        import snapcontext as sc
+
+        ok = self.aplicar_parche(diff, directorio,
+                                 contenido_esperado=contenido_actual)
+        if ok or auto:
+            return "ok" if ok else "reintentar"
+        while True:
+            opcion = sc._menu_conflicto_parche()
+            if opcion == "a":
+                # Aplicar de todas formas: usa el preview ya calculado si lo
+                # hay; si no, reintenta el parche sin comprobación previa.
+                if preview is not None:
+                    return ("ok" if self.sobrescribir(archivo, preview,
+                                                      directorio)
+                            else "cancelar")
+                ok2 = self.aplicar_parche(diff, directorio)
+                if ok2:
+                    return "ok"
+                sc.error("El parche sigue sin aplicarse incluso sin "
+                         "comprobación previa.")
+                continue
+            if opcion == "v":
+                print("--- Diff propuesto ---")
+                print(diff)
+                print("----------------------")
+                continue
+            if opcion == "r":
+                return "reintentar"
+            sc.info(f"Se conserva la versión original de '{archivo}'.")
+            return "cancelar"
+
     def _aplicar_modo_sobrescribir(self, archivo: str, mensaje: str,
                                    contenido_actual: str, modelo: Optional[str],
                                    directorio: str, validar: bool = True,
-                                   max_intentos_validacion: int = 3) -> bool:
+                                   max_intentos_validacion: int = 3,
+                                   conciso: bool = False) -> bool:
         """Sobrescribe `archivo` con el código completo que devuelve el proveedor."""
         import snapcontext as sc
 
@@ -374,22 +463,32 @@ class AgenteEditorPropio:
         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:
+            if conciso:
+                # v4.1.0: variante reducida para modelos ligeros (Ollama).
+                prompt = (
+                    f"Tarea: {mensaje}\n"
+                    f"Devuelve SOLO el código completo final de {archivo}:\n"
+                    f"```\n{contenido_actual}\n```"
+                )
+            else:
+                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"\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"
+                    f"\nContenido actual completo:\n```{lenguaje}\n{contenido_actual}\n```\n\n"
+                    f"Devuelve ÚNICAMENTE el código completo resultante, sin explicaciones ni markdown."
                 )
-            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."
-            )
+            if error_msj and conciso:
+                prompt += (f"\n\nError anterior a corregir: {error_msj}")
             respuesta = sc._enviar_al_proveedor(
                 proveedor, modelo, [{"role": "user", "content": prompt}])
             nuevo_contenido = respuesta
@@ -428,6 +527,9 @@ class AgenteEditorPropio:
         modelo: Optional[str] = None,
         validar: bool = True,
         max_intentos_validacion: int = 3,
+        proveedor: Optional[str] = None,
+        modelo_ligero: bool = False,
+        auto: bool = False,
     ) -> bool:
         """Aplica las modificaciones para `archivos` con el `mensaje` especificado.
 
@@ -436,12 +538,23 @@ class AgenteEditorPropio:
         - modo_edicion == 'ast': edita con base en el AST y cae a sobrescritura si falla.
         - modo_edicion == 'auto': decide por heurística (AST para refactorizaciones,
           parche, y fallback a sobrescritura).
+
+        v4.1.0:
+        - Transparencia: informa la estrategia en uso antes de cada intento.
+        - Prompts concisos automáticos con Ollama o ``modelo_ligero=True``.
+        - Resolución interactiva de conflictos de parche (omitida con ``auto``).
+        - Al fallar todo, error claro con estrategias intentadas + sugerencia
+          ``--editor aider`` y registro del fallo en ~/.snapcontext/logs/.
         """
         import snapcontext as sc
         from pathlib import Path
 
         raiz = Path(directorio).resolve()
         todo_ok = True
+        conciso = _prompts_concisos(
+            _proveedor_efectivo(proveedor), modelo_ligero)
+        if conciso:
+            sc.info("Editor propio: usando prompts concisos (modelo ligero).")
 
         # 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
@@ -472,20 +585,25 @@ class AgenteEditorPropio:
                 cadena.insert(0, estrategia_aprendida)
             conseguido = False
             for estrategia in cadena:
+                sc.info(f"Editor propio: usando estrategia "
+                        f"{estrategia.upper()} para '{arch}'...")
                 try:
                     if estrategia == "ast":
                         conseguido = self.editar_ast(arch, mensaje,
-                                                     str(raiz), modelo)
+                                                     str(raiz), modelo,
+                                                     conciso=conciso)
                     elif estrategia == "parche":
                         conseguido = self._aplicar_modo_parche(
                             arch, mensaje, contenido_actual, modelo, str(raiz),
                             validar=validar,
-                            max_intentos_validacion=max_intentos_validacion)
+                            max_intentos_validacion=max_intentos_validacion,
+                            conciso=conciso, auto=auto)
                     elif estrategia == "sobrescribir":
                         conseguido = self._aplicar_modo_sobrescribir(
                             arch, mensaje, contenido_actual, modelo, str(raiz),
                             validar=validar,
-                            max_intentos_validacion=max_intentos_validacion)
+                            max_intentos_validacion=max_intentos_validacion,
+                            conciso=conciso)
                     else:
                         conseguido = False
                 except Exception as exc:
@@ -506,7 +624,22 @@ class AgenteEditorPropio:
                     except Exception as exc:
                         sc.depurar(f"[skills] Refuerzo falló: {exc}")
             else:
-                sc.error(f"[AgenteEditorPropio] No se pudo editar '{arch}'.")
+                # v4.1.0: mensaje claro con estrategias intentadas, motivo y
+                # sugerencia; además se registra en ~/.snapcontext/logs/.
+                estrategias_txt = " → ".join(cadena)
+                sc.error(
+                    f"✖ El editor propio no pudo completar la edición.\n"
+                    f"  Archivo: {arch}\n"
+                    f"  Estrategias intentadas: {estrategias_txt}\n"
+                    f"  Motivo: ninguna estrategia produjo un cambio válido "
+                    f"(revisa la salida anterior).\n"
+                    f"  Sugerencia: prueba con '--editor aider' o revisa la "
+                    f"tarea manualmente.")
+                try:
+                    sc._registrar_fallo_editor(arch, mensaje, cadena,
+                                               "sin cambio válido")
+                except Exception:
+                    pass
                 todo_ok = False
 
         return todo_ok
@@ -681,11 +814,28 @@ class AgenteAsesor:
     """
 
     def analizar(self, directorio: str = ".",
-                 umbral_funcion: Optional[int] = None) -> List[dict]:
-        """Ejecuta el análisis estático y devuelve la lista de sugerencias."""
+                 umbral_funcion: Optional[int] = None,
+                 profundo: bool = False) -> List[dict]:
+        """Ejecuta el análisis estático y devuelve la lista de sugerencias.
+
+        Con ``profundo=True`` añade seguridad 🔒 y rendimiento ⚡ (v4.2.0).
+        """
+        import snapcontext as sc
+
+        return sc._asesor_analizar(directorio, umbral_funcion=umbral_funcion,
+                                   profundo=profundo)
+
+    def analizar_seguridad(self, directorio: str = ".") -> List[dict]:
+        """Solo vulnerabilidades de seguridad (v4.2.0)."""
+        import snapcontext as sc
+
+        return sc._analizar_seguridad(directorio)
+
+    def analizar_rendimiento(self, directorio: str = ".") -> List[dict]:
+        """Solo sugerencias de rendimiento (v4.2.0)."""
         import snapcontext as sc
 
-        return sc._asesor_analizar(directorio, umbral_funcion=umbral_funcion)
+        return sc._analizar_rendimiento(directorio)
 
     def mostrar(self, sugerencias: List[dict]) -> None:
         """Muestra las sugerencias en la CLI con colores."""

{snapcontext-4.0.0 → snapcontext-4.2.0}/orquestador.py

@@ -207,6 +207,9 @@ class Orquestador:
                         validar=getattr(args, "validar", True),
                         max_intentos_validacion=getattr(
                             args, "max_intentos_validacion", 3),
+                        proveedor=getattr(args, "provider", None),
+                        modelo_ligero=getattr(args, "modelo_ligero", False),
+                        auto=getattr(args, "auto", False),
                     )
                     self._emitir_tipo("editor", accion="fin", ok=ok)
                 else:

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