snapcontext 3.1.0__tar.gz → 3.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 3.1.0
+Version: 3.2.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -85,7 +85,7 @@ pip install aider-chat                  # ediciones de código
 snapcontext --init                      # asistente inicial + API key
 ```
 
-## 🧰 Instalación y onboarding sin fricción (v3.1.0)
+## 🧰 Instalación y onboarding sin fricción (v3.1.x)
 
 Objetivo: instalar SnapContext y empezar a usarlo en menos de 5 minutos.
 
@@ -117,6 +117,11 @@ Arregla instalaciones rotas:
 
 ### Tutorial y asistente mejorados
 - `snapcontext --bienvenida`: tutorial interactivo de primeros pasos.
+- **(v3.1.1)** `snapcontext` sin argumentos muestra una ayuda resumida y
+  amigable con ejemplos (código 0), en lugar de un error.
+- **(v3.1.1)** En el primer uso se ejecuta la bienvenida automáticamente:
+  se registra en `~/.snapcontext/estado.json` (`"primer_uso": false`) para
+  no repetirla; `--bienvenida` explícito permite volver a verla.
 - `snapcontext --init` ahora también pregunta si quieres configurar Ollama
   (ofreciendo abrir <https://ollama.com>), crear un proyecto de prueba y
   ejecutar el tutorial interactivo.
@@ -129,6 +134,15 @@ El instalador NSIS (`installer.nsi`, generado con
   comando `snapcontext` disponible en cualquier terminal.
 - Sigue añadiendo la carpeta al PATH y creando accesos directos.
 
+### Extensión VS Code en TypeScript (v3.2.0)
+La extensión vive en `vscode/` y está escrita en TypeScript:
+- `vscode/src/extension.ts` — código fuente tipado (modo `strict`).
+- `vscode/tsconfig.json` — ES2020, commonjs, salida en `out/`.
+- Compilar: `cd vscode && npm install && npm run compile` (genera
+  `out/extension.js`, que es el entry point del manifiesto).
+- Empaquetar: `vscode/scripts/empaquetar.ps1` / `.sh` (compilan antes de
+  ejecutar `vsce package`).
+
 ## 🚀 Inicio rápido (5 minutos)
 
 ```bash

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

@@ -40,7 +40,7 @@ pip install aider-chat                  # ediciones de código
 snapcontext --init                      # asistente inicial + API key
 ```
 
-## 🧰 Instalación y onboarding sin fricción (v3.1.0)
+## 🧰 Instalación y onboarding sin fricción (v3.1.x)
 
 Objetivo: instalar SnapContext y empezar a usarlo en menos de 5 minutos.
 
@@ -72,6 +72,11 @@ Arregla instalaciones rotas:
 
 ### Tutorial y asistente mejorados
 - `snapcontext --bienvenida`: tutorial interactivo de primeros pasos.
+- **(v3.1.1)** `snapcontext` sin argumentos muestra una ayuda resumida y
+  amigable con ejemplos (código 0), en lugar de un error.
+- **(v3.1.1)** En el primer uso se ejecuta la bienvenida automáticamente:
+  se registra en `~/.snapcontext/estado.json` (`"primer_uso": false`) para
+  no repetirla; `--bienvenida` explícito permite volver a verla.
 - `snapcontext --init` ahora también pregunta si quieres configurar Ollama
   (ofreciendo abrir <https://ollama.com>), crear un proyecto de prueba y
   ejecutar el tutorial interactivo.
@@ -84,6 +89,15 @@ El instalador NSIS (`installer.nsi`, generado con
   comando `snapcontext` disponible en cualquier terminal.
 - Sigue añadiendo la carpeta al PATH y creando accesos directos.
 
+### Extensión VS Code en TypeScript (v3.2.0)
+La extensión vive en `vscode/` y está escrita en TypeScript:
+- `vscode/src/extension.ts` — código fuente tipado (modo `strict`).
+- `vscode/tsconfig.json` — ES2020, commonjs, salida en `out/`.
+- Compilar: `cd vscode && npm install && npm run compile` (genera
+  `out/extension.js`, que es el entry point del manifiesto).
+- Empaquetar: `vscode/scripts/empaquetar.ps1` / `.sh` (compilan antes de
+  ejecutar `vsce package`).
+
 ## 🚀 Inicio rápido (5 minutos)
 
 ```bash

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 3.1.0
+Version: 3.2.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -85,7 +85,7 @@ pip install aider-chat                  # ediciones de código
 snapcontext --init                      # asistente inicial + API key
 ```
 
-## 🧰 Instalación y onboarding sin fricción (v3.1.0)
+## 🧰 Instalación y onboarding sin fricción (v3.1.x)
 
 Objetivo: instalar SnapContext y empezar a usarlo en menos de 5 minutos.
 
@@ -117,6 +117,11 @@ Arregla instalaciones rotas:
 
 ### Tutorial y asistente mejorados
 - `snapcontext --bienvenida`: tutorial interactivo de primeros pasos.
+- **(v3.1.1)** `snapcontext` sin argumentos muestra una ayuda resumida y
+  amigable con ejemplos (código 0), en lugar de un error.
+- **(v3.1.1)** En el primer uso se ejecuta la bienvenida automáticamente:
+  se registra en `~/.snapcontext/estado.json` (`"primer_uso": false`) para
+  no repetirla; `--bienvenida` explícito permite volver a verla.
 - `snapcontext --init` ahora también pregunta si quieres configurar Ollama
   (ofreciendo abrir <https://ollama.com>), crear un proyecto de prueba y
   ejecutar el tutorial interactivo.
@@ -129,6 +134,15 @@ El instalador NSIS (`installer.nsi`, generado con
   comando `snapcontext` disponible en cualquier terminal.
 - Sigue añadiendo la carpeta al PATH y creando accesos directos.
 
+### Extensión VS Code en TypeScript (v3.2.0)
+La extensión vive en `vscode/` y está escrita en TypeScript:
+- `vscode/src/extension.ts` — código fuente tipado (modo `strict`).
+- `vscode/tsconfig.json` — ES2020, commonjs, salida en `out/`.
+- Compilar: `cd vscode && npm install && npm run compile` (genera
+  `out/extension.js`, que es el entry point del manifiesto).
+- Empaquetar: `vscode/scripts/empaquetar.ps1` / `.sh` (compilan antes de
+  ejecutar `vsce package`).
+
 ## 🚀 Inicio rápido (5 minutos)
 
 ```bash

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

@@ -13,6 +13,7 @@ snapcontext.egg-info/top_level.txt
 snapcontext.egg-info/__pycache__/top_level.cpython-313.pyc
 tests/test_agentes.py
 tests/test_auto_017.py
+tests/test_bienvenida_311.py
 tests/test_deteccion.py
 tests/test_diagnostico_310.py
 tests/test_diff_editor_210.py
@@ -32,6 +33,7 @@ tests/test_plan_mcp_230.py
 tests/test_v010.py
 tests/test_validacion_130.py
 tests/test_vscode_016.py
+tests/test_vscode_ts_320.py
 tests/test_web_120.py
 tests/test_web_160.py
 web/__init__.py

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

@@ -111,7 +111,7 @@ except ImportError:  # pragma: no cover
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 
-VERSION = "3.1.0"
+VERSION = "3.2.0"
 
 # v3.1.0 — Claves de API reconocidas para el modo por defecto (offline).
 CLAVES_API_CONOCIDAS = (
@@ -294,6 +294,8 @@ MODELO_DEFECTO = os.environ.get("SNAPCONTEXT_MODELO") or None
 # Preferencias guardadas (~/.snapcontext/config.json): proveedor y modelo.
 CONFIG_DIR = Path.home() / ".snapcontext"
 CONFIG_PATH = CONFIG_DIR / "config.json"
+# v3.1.1: estado ligero de primer uso (~/.snapcontext/estado.json).
+ESTADO_PATH = CONFIG_DIR / "estado.json"
 BACKUPS_DIR = CONFIG_DIR / "backups"
 MAX_ARCHIVOS_DEFECTO = 3                           # archivos que recibe Aider
 MAX_CANDIDATOS_DEFECTO = 80                        # candidatos que se envían al selector IA
@@ -1088,6 +1090,54 @@ def seleccionar_archivos_con_anthropic(consulta: str, archivos: List[str],
     return normalizar_seleccion(parsear_json(texto), archivos, max_archivos)
 
 
+# ---------------------------------------------------------------------------
+# Estado de primer uso (v3.1.1): ~/.snapcontext/estado.json
+# ---------------------------------------------------------------------------
+def _cargar_estado() -> dict:
+    """Lee ~/.snapcontext/estado.json. Devuelve {} si no existe o falla."""
+    try:
+        if ESTADO_PATH.is_file():
+            datos = json.loads(ESTADO_PATH.read_text(encoding="utf-8"))
+            if isinstance(datos, dict):
+                return datos
+    except (json.JSONDecodeError, OSError):
+        pass
+    return {}
+
+
+def _guardar_estado(datos: dict) -> bool:
+    """Escribe el dict de estado en ESTADO_PATH. True si tuvo éxito."""
+    try:
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        ESTADO_PATH.write_text(
+            json.dumps(datos, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8")
+        return True
+    except OSError:
+        return False
+
+
+def _primer_uso_pendiente() -> bool:
+    """True si la bienvenida aún no se ha mostrado (estado ausente o True)."""
+    estado = _cargar_estado()
+    return bool(estado.get("primer_uso", True))
+
+
+def _marcar_primer_uso_completado() -> None:
+    """Guarda primer_uso=False (nunca rompe el flujo principal)."""
+    estado = _cargar_estado()
+    estado["primer_uso"] = False
+    _guardar_estado(estado)
+
+
+def _entrada_interactiva() -> bool:
+    """True si stdin es un terminal (evita bloqueos en tests/CI/scripts)."""
+    try:
+        return sys.stdin is not None and sys.stdin.isatty()
+    except (AttributeError, ValueError):       # pragma: no cover
+        return False
+
+
 def cargar_configuracion() -> dict:
     """Lee la configuración guardada en ~/.snapcontext/config.json.
 
@@ -6633,6 +6683,42 @@ def _construir_ayuda(parser: argparse.ArgumentParser) -> str:
 
 
 
+def _mostrar_ayuda_resumida() -> None:
+    """Ayuda amigable cuando se ejecuta `snapcontext` sin argumentos (v3.1.1).
+
+    Más corta que --help: comandos de uso común con ejemplos listos para
+    copiar y pegar.
+    """
+    print(_LOGO_SMALL)
+    lineas = [
+        "Bienvenido a SnapContext — tu asistente de IA con contexto automático.",
+        "",
+        _pintar("Uso básico:", _CYAN),
+        '  snapcontext "describe lo que quieres cambiar"',
+        "",
+        _pintar("Comandos más útiles:", _CYAN),
+        "  snapcontext --bienvenida     Tutorial interactivo de primeros pasos",
+        "  snapcontext --init           Configurar claves API y proveedor",
+        "  snapcontext --diagnostico    Revisar tu instalación",
+        "  snapcontext --reparar        Arreglar una instalación rota",
+        "  snapcontext --demo           Demo autónoma (sin API key)",
+        "  snapcontext --chat           Conversar con el proveedor de IA",
+        "  snapcontext --plan \"tarea\"   Planificar y ejecutar paso a paso",
+        "  snapcontext --help           Ayuda completa agrupada",
+        "",
+        _pintar("Ejemplos:", _CYAN),
+        '  snapcontext "el botón de pago no funciona"',
+        '  snapcontext "añadir login" --test-loop',
+        '  snapcontext "revisar pago" --vista-previa   # solo ver, no editar',
+        "",
+        _pintar("Sin API key", _CYAN) +
+        ": SnapContext usa Ollama local automáticamente (modo offline).",
+        "Instala Ollama desde https://ollama.com y ejecuta: ollama pull llama3.2",
+        "",
+    ]
+    print("\n".join(lineas))
+
+
 class _AyudaAccion(argparse.Action):
     """Muestra la ayuda agrupada por categorías y termina."""
 
@@ -7672,12 +7758,31 @@ def main(argv: Optional[List[str]] = None) -> int:
         # Al ejecutar como script (`python snapcontext.py ...`) argparse debe
         # ver los argumentos reales; si pasáramos [] vacío, se perderían.
         argv = sys.argv[1:]
+    # v3.1.1: sin argumentos → ayuda resumida y amigable (no un error).
+    if not argv:
+        _mostrar_ayuda_resumida()
+        return 0
     args = crear_parser().parse_args(_preparar_argv_aliases(argv))
     try:
         # Permisos (v0.13.0): sincroniza el interruptor global con --confirmar
         # para todos los modos (chat, planificador, ...).
         global CONFIRMAR_ACCIONES
         CONFIRMAR_ACCIONES = getattr(args, "confirmar", True)
+        # v3.1.1: --bienvenida explícito ejecuta el tutorial y marca el
+        # primer uso como completado (por si quiere volver a verlo).
+        if getattr(args, "bienvenida", False):
+            codigo = _tutorial_interactivo()
+            _marcar_primer_uso_completado()
+            return codigo
+        # v3.1.1: primer uso → tutorial automático y se continúa con el
+        # comando pedido. Solo en terminales interactivos (nunca en tests,
+        # CI o scripts) para evitar bloqueos.
+        if _primer_uso_pendiente() and _entrada_interactiva():
+            info("👋 Parece que es tu primera vez con SnapContext. "
+                 "Mostrando el tutorial (--bienvenida)...")
+            print()
+            _tutorial_interactivo()
+            _marcar_primer_uso_completado()
         # --init-claude es independiente: crea la memoria del proyecto y sale.
         if getattr(args, "init_claude", False):
             _generar_claude_md(getattr(args, "provider", None),
@@ -7702,8 +7807,6 @@ def main(argv: Optional[List[str]] = None) -> int:
             return _ejecutar_diagnostico(args)
         if getattr(args, "reparar", False):
             return _ejecutar_reparacion(args)
-        if getattr(args, "bienvenida", False):
-            return _tutorial_interactivo()
         # --web inicia la interfaz web (FastAPI + WebSockets) y bloquea hasta parar.
         if getattr(args, "web", False):
             return iniciar_servidor_web(args)

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

snapcontext-3.2.0/tests/test_bienvenida_311.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests de la v3.1.1: ayuda sin argumentos y bienvenida en el primer uso."""
+
+import io
+import json
+import os
+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
+
+
+class _EstadoTemporal(unittest.TestCase):
+    """Aísla ESTADO_PATH en un directorio temporal por test."""
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.estado = Path(self._tmp.name) / "estado.json"
+        patcher = mock.patch.object(sc, "ESTADO_PATH", self.estado)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.addCleanup(self._tmp.cleanup)
+
+
+class TestAyudaSinArgumentos(_EstadoTemporal):
+    """`snapcontext` sin argumentos muestra la ayuda resumida (código 0)."""
+
+    def test_main_sin_args_muestra_ayuda_y_devuelve_0(self):
+        buffer = io.StringIO()
+        with mock.patch.object(sys, "stdout", buffer), \
+                mock.patch.object(sc, "_registrar_manejadores_senales"):
+            codigo = sc.main([])
+        self.assertEqual(codigo, 0)
+        salida = buffer.getvalue()
+        self.assertIn("snapcontext --bienvenida", salida)
+        self.assertIn("snapcontext --diagnostico", salida)
+        self.assertIn("Ejemplos:", salida)
+
+    def test_mostrar_ayuda_resumida_contiene_comandos_clave(self):
+        buffer = io.StringIO()
+        with mock.patch.object(sys, "stdout", buffer):
+            sc._mostrar_ayuda_resumida()
+        salida = buffer.getvalue()
+        for fragmento in ("--init", "--reparar", "--demo", "--chat",
+                          "--plan", "ollama"):
+            self.assertIn(fragmento, salida)
+
+
+class TestEstadoPrimerUso(_EstadoTemporal):
+    """Helpers de estado: primer_uso en ~/.snapcontext/estado.json."""
+
+    def test_estado_ausente_significa_primer_uso(self):
+        self.assertFalse(self.estado.exists())
+        self.assertTrue(sc._primer_uso_pendiente())
+
+    def test_marcar_completado_crea_estado(self):
+        sc._marcar_primer_uso_completado()
+        self.assertTrue(self.estado.exists())
+        datos = json.loads(self.estado.read_text(encoding="utf-8"))
+        self.assertFalse(datos["primer_uso"])
+        self.assertFalse(sc._primer_uso_pendiente())
+
+    def test_primer_uso_false_en_archivo(self):
+        self.estado.write_text(json.dumps({"primer_uso": False}),
+                               encoding="utf-8")
+        self.assertFalse(sc._primer_uso_pendiente())
+
+    def test_estado_corrupto_se_trata_como_primer_uso(self):
+        self.estado.write_text("{no es json", encoding="utf-8")
+        self.assertTrue(sc._primer_uso_pendiente())
+
+
+class TestBienvenidaAutomatica(_EstadoTemporal):
+    """Primer uso → tutorial automático; después ya no se repite."""
+
+    def _ejecutar_main_con_mocks(self):
+        llamadas = []
+        with mock.patch.object(sc, "_tutorial_interactivo",
+                               side_effect=lambda: llamadas.append(1) or 0), \
+                mock.patch.object(sc, "_entrada_interactiva",
+                                  return_value=True), \
+                mock.patch.object(sc, "_registrar_manejadores_senales"), \
+                mock.patch.object(sc, "_limpiar_historial", return_value=True), \
+                mock.patch.object(sys, "stdout", io.StringIO()), \
+                mock.patch.object(sys, "stderr", io.StringIO()):
+            codigo = sc.main(["--historial-limpiar"])
+        return codigo, llamadas
+
+    def test_primera_ejecucion_lanza_bienvenida_y_marca_estado(self):
+        codigo, llamadas = self._ejecutar_main_con_mocks()
+        self.assertEqual(codigo, 0)
+        self.assertEqual(len(llamadas), 1)
+        self.assertFalse(sc._primer_uso_pendiente())
+
+    def test_segunda_ejecucion_no_repite_bienvenida(self):
+        self._ejecutar_main_con_mocks()
+        _, llamadas = self._ejecutar_main_con_mocks()
+        self.assertEqual(len(llamadas), 0)
+
+    def test_entrada_no_interactiva_no_bloquea(self):
+        with mock.patch.object(sc, "_tutorial_interactivo") as tutorial, \
+                mock.patch.object(sc, "_entrada_interactiva",
+                                  return_value=False), \
+                mock.patch.object(sc, "_registrar_manejadores_senales"), \
+                mock.patch.object(sc, "_limpiar_historial", return_value=True), \
+                mock.patch.object(sys, "stdout", io.StringIO()), \
+                mock.patch.object(sys, "stderr", io.StringIO()):
+            sc.main(["--historial-limpiar"])
+        tutorial.assert_not_called()
+        # El estado no se marca: se mostrará en una sesión interactiva real.
+        self.assertTrue(sc._primer_uso_pendiente())
+
+
+class TestBienvenidaExplicita(_EstadoTemporal):
+    """--bienvenida explícito ejecuta el tutorial y marca el estado."""
+
+    def test_flag_bienvenida_marca_primer_uso(self):
+        with mock.patch.object(sc, "_tutorial_interactivo", return_value=0), \
+                mock.patch.object(sc, "_registrar_manejadores_senales"), \
+                mock.patch.object(sys, "stdout", io.StringIO()):
+            codigo = sc.main(["--bienvenida"])
+        self.assertEqual(codigo, 0)
+        self.assertFalse(sc._primer_uso_pendiente())
+
+
+if __name__ == "__main__":
+    unittest.main()

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

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

@@ -96,7 +96,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.1.0")
+        self.assertEqual(sc.VERSION, "3.2.0")
 
 
 if __name__ == "__main__":

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

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

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

{snapcontext-3.1.0 → snapcontext-3.2.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.1.0")
+        self.assertEqual(sc.VERSION, "3.2.0")
 
 
 class TestEstructuraJetBrains(unittest.TestCase):
@@ -102,8 +102,10 @@ class TestGradleYKotlin(unittest.TestCase):
         self.assertIn("GEMINI_API_KEY", servicio)        # clave opcional
 
     def test_contexto_como_vscode(self):
-        # Mismo mecanismo de contexto visual que la extensión de VS Code.
-        vscode = (RAIZ / "vscode" / "extension.js").read_text(encoding="utf-8")
+        # Mismo mecanismo de contexto visual que la extensión de VS Code
+        # (migrada a TypeScript en v3.2.0).
+        vscode = (RAIZ / "vscode" / "src" / "extension.ts").read_text(
+            encoding="utf-8")
         kotlin = (JB / "src/main/kotlin/com/snapcontext/jetbrains/"
                   "SnapContextService.kt").read_text(encoding="utf-8")
         self.assertIn("Revisa especialmente estos archivos:", vscode)

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

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

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

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

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

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

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

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

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

{snapcontext-3.1.0 → snapcontext-3.2.0}/tests/test_vscode_016.py

@@ -22,7 +22,8 @@ import snapcontext as sc
 
 class TestEstructuraVsCode(unittest.TestCase):
     def test_archivos_obligatorios_existen(self):
-        for relativo in ("package.json", "extension.js",
+        for relativo in ("package.json", "tsconfig.json",
+                         "src/extension.ts",
                          "webview/index.html", "webview/servidor_webview.py",
                          "scripts/empaquetar.ps1", "scripts/empaquetar.sh"):
             self.assertTrue((VSCODE / relativo).is_file(), relativo)
@@ -30,8 +31,8 @@ class TestEstructuraVsCode(unittest.TestCase):
     def test_package_json_valido(self):
         manifiesto = json.loads((VSCODE / "package.json").read_text("utf-8"))
         self.assertEqual(manifiesto["name"], "snapcontext-vscode")
-        self.assertEqual(manifiesto["version"], "2.2.0")
-        self.assertEqual(manifiesto["main"], "./extension.js")
+        self.assertEqual(manifiesto["version"], "3.2.0")
+        self.assertEqual(manifiesto["main"], "./out/extension.js")
 
     def test_comandos_contribuidos(self):
         manifiesto = json.loads((VSCODE / "package.json").read_text("utf-8"))
@@ -56,8 +57,8 @@ class TestEstructuraVsCode(unittest.TestCase):
                          "snapcontext.apiKey", "snapcontext.confirmar"):
             self.assertIn(esperada, propiedades)
 
-    def test_extension_js_registra_los_comandos(self):
-        codigo = (VSCODE / "extension.js").read_text(encoding="utf-8")
+    def test_extension_ts_registra_los_comandos(self):
+        codigo = (VSCODE / "src" / "extension.ts").read_text(encoding="utf-8")
         for comando in ("abrirChat", "ejecutarConsulta", "planificar",
                         "configurarApiKey", "anadirAlContexto",
                         "limpiarSeleccion"):
@@ -65,10 +66,13 @@ class TestEstructuraVsCode(unittest.TestCase):
         # Canal de salida dedicado.
         self.assertIn('"SnapContext Output"', codigo)
         # Usa la CLI/módulo python con el workspace como directorio.
-        self.assertIn("-m\", \"snapcontext", codigo.replace('", "', '", "'))
+        self.assertIn('"-m", "snapcontext"', codigo)
         self.assertIn("cwd: ws", codigo)
         self.assertIn("--no-confirmar", codigo)
         self.assertIn("--plan", codigo)
+        # Migración a TypeScript (v3.2.0).
+        self.assertIn("import * as vscode from \"vscode\"", codigo)
+        self.assertIn("vscode.ExtensionContext", codigo)
 
     def test_webview_es_copia_de_la_interfaz_web(self):
         web = (RAIZ / "web" / "static" / "index.html").read_text(
@@ -87,7 +91,7 @@ class TestEstructuraVsCode(unittest.TestCase):
 
 class TestVersionCli(unittest.TestCase):
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "3.1.0")
+        self.assertEqual(sc.VERSION, "3.2.0")
 
 
 if __name__ == "__main__":

snapcontext-3.2.0/tests/test_vscode_ts_320.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests de la migración a TypeScript de la extensión VS Code — v3.2.0.
+
+Validan la configuración TypeScript, el entry point compilado y que los
+comandos se registran en ``src/extension.ts``. Si hay un compilador
+disponible (node_modules o npx), también ejecutan ``tsc --noEmit``.
+"""
+
+import json
+import shutil
+import subprocess
+import unittest
+from pathlib import Path
+
+RAIZ = Path(__file__).resolve().parents[1]
+VSCODE = RAIZ / "vscode"
+TSCONFIG_OBLIGATORIO = {
+    "target": "ES2020",
+    "module": "commonjs",
+    "strict": True,
+    "esModuleInterop": True,
+    "skipLibCheck": True,
+    "forceConsistentCasingInFileNames": True,
+    "outDir": "./out",
+    "rootDir": "./src",
+    "sourceMap": True,
+    "declaration": True,
+}
+
+
+def _leer_json(ruta: Path) -> dict:
+    return json.loads(ruta.read_text("utf-8"))
+
+
+class TestTsConfig(unittest.TestCase):
+    def test_tsconfig_existe_y_tiene_opciones_obligatorias(self):
+        opciones = _leer_json(VSCODE / "tsconfig.json")["compilerOptions"]
+        for clave, valor in TSCONFIG_OBLIGATORIO.items():
+            self.assertEqual(opciones.get(clave), valor,
+                             f"compilerOptions['{clave}']")
+
+    def test_tsconfig_include_exclude(self):
+        config = _leer_json(VSCODE / "tsconfig.json")
+        self.assertIn("src/**/*", config["include"])
+        for excluido in ("node_modules", "out", "webview"):
+            self.assertIn(excluido, config["exclude"])
+
+
+class TestPackageJsonTypeScript(unittest.TestCase):
+    def setUp(self):
+        self.manifiesto = _leer_json(VSCODE / "package.json")
+
+    def test_main_apunta_a_out(self):
+        self.assertEqual(self.manifiesto["main"], "./out/extension.js")
+
+    def test_scripts_de_compilacion(self):
+        scripts = self.manifiesto["scripts"]
+        self.assertEqual(scripts["compile"], "tsc -p ./")
+        self.assertEqual(scripts["watch"], "tsc -watch -p ./")
+        self.assertEqual(scripts["package"], "vsce package")
+        # El empaquetado compila antes de generar el .vsix.
+        self.assertIn("compile", scripts["vscode:prepublish"])
+
+    def test_dev_dependencies_typescript(self):
+        dev = self.manifiesto["devDependencies"]
+        for paquete in ("typescript", "@types/vscode", "@types/node"):
+            self.assertIn(paquete, dev)
+
+
+class TestExtensionTs(unittest.TestCase):
+    """El código TypeScript mantiene la funcionalidad de la v0.16.0."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.codigo = (VSCODE / "src" / "extension.ts").read_text("utf-8")
+
+    def test_imports_modulo_vscode(self):
+        self.assertIn('import * as vscode from "vscode"', self.codigo)
+
+    def test_activate_tipado(self):
+        self.assertIn("export function activate("
+                      "context: vscode.ExtensionContext): void",
+                      self.codigo)
+        self.assertIn("export function deactivate(): void", self.codigo)
+
+    def test_comandos_registrados(self):
+        for comando in ("snapcontext.abrirChat", "snapcontext.ejecutarConsulta",
+                        "snapcontext.planificar", "snapcontext.configurarApiKey",
+                        "snapcontext.anadirAlContexto",
+                        "snapcontext.limpiarSeleccion"):
+            self.assertIn(f'"{comando}"', self.codigo)
+        # Los registros pasan por registerCommand (disposables en subscriptions).
+        self.assertIn("registerCommand", self.codigo)
+        self.assertIn("subscriptions.push(disposable)", self.codigo)
+
+    def test_webview_sigue_sirviendo_el_servidor_web(self):
+        self.assertIn("createWebviewPanel", self.codigo)
+        self.assertIn("http://localhost:${puerto}", self.codigo)
+        self.assertIn("esperarPuerto(puerto, 10000)", self.codigo)
+        # Puerto dinámico: parte en 8765 y busca uno libre.
+        self.assertIn("let puerto = 8765", self.codigo)
+
+    def test_tipos_completos_en_firmas(self):
+        self.assertIn(": vscode.OutputChannel | null", self.codigo)
+        self.assertIn(": vscode.StatusBarItem | null", self.codigo)
+        self.assertIn("uri?: vscode.Uri", self.codigo)
+        self.assertIn("Promise<number>", self.codigo)
+        self.assertIn("ChildProcessWithoutNullStreams | null", self.codigo)
+
+
+class TestCompilacionReal(unittest.TestCase):
+    """Ejecuta `tsc --noEmit` si hay un compilador disponible."""
+
+    def test_tsc_no_emit_pasa_si_hay_compilador(self):
+        tsc_local = VSCODE / "node_modules" / ".bin" / ("tsc.cmd"
+                     if shutil.which("node") and Path(VSCODE /
+                       "node_modules/.bin/tsc.cmd").exists() else "tsc")
+        if not tsc_local.exists():
+            self.skipTest("TypeScript no está instalado (npm install)")
+        proc = subprocess.run(
+            [str(tsc_local), "--noEmit", "-p", str(VSCODE / "tsconfig.json")],
+            capture_output=True, text=True, timeout=120)
+        self.assertEqual(proc.returncode, 0,
+                         f"tsc --noEmit falló:\n{proc.stdout}\n{proc.stderr}")
+
+    def test_out_extension_js_generado_tras_compilar(self):
+        compilado = VSCODE / "out" / "extension.js"
+        if not compilado.exists():
+            self.skipTest("La extensión aún no se ha compilado "
+                          "(ejecuta npm run compile)")
+        codigo = compilado.read_text("utf-8")
+        for comando in ("snapcontext.abrirChat", "snapcontext.planificar"):
+            self.assertIn(comando, codigo)
+
+
+if __name__ == "__main__":
+    unittest.main()

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