context-map-ai 2.0.0__py3-none-any.whl

context_map/__init__.py

@@ -0,0 +1 @@
+__all__ = ["build_map"]

context_map/__tests__/conftest.py

@@ -0,0 +1,33 @@
+"""Configuración compartida de pytest.
+
+Aísla la base de datos personal de ContextMap durante los tests: cualquier
+``do_sync`` (build/scan/refresh) que se ejecute en la suite consolida en una
+BD temporal, jamás en la BD personal real del usuario (F: / ~/.context-map).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import tempfile
+from collections.abc import Generator
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _aislar_bd_personal(monkeypatch: pytest.MonkeyPatch) -> Generator[None, None, None]:
+    """Redirige CTXMAP_PERSONAL_DB a una ruta temporal por test.
+
+    Args:
+        monkeypatch: Fixture de pytest para parchear variables de entorno.
+
+    Yields:
+        None: cede el control al test con la variable ya parcheada.
+    """
+    fd, ruta_tmp = tempfile.mkstemp(prefix="ctxmap_test_personal_", suffix=".db")
+    os.close(fd)
+    monkeypatch.setenv("CTXMAP_PERSONAL_DB", ruta_tmp)
+    yield
+    with contextlib.suppress(OSError):
+        os.remove(ruta_tmp)

context_map/__tests__/smoke.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from context_map.core.models import Edge, Node
+from context_map.presentation.vault import render_active_map
+
+
+def test_smoke_render() -> None:
+    """
+    Verifica que el writer genera el mapa esperado.
+    """
+    nodes: list[Node] = [
+        Node(id="BASE-01", type="BASE", title="Demo", summary="demo", source="test")
+    ]
+    edges: list[Edge] = [Edge(source="BASE-01", target="IDEA-01", kind="depends_on")]
+    md = render_active_map("Demo", nodes, edges)
+    assert "# Demo — Context Map" in md
+    assert "## Mapa mental de contexto" in md
+    assert "## Conexiones" in md
+
+
+if __name__ == "__main__":
+    test_smoke_render()
+    print("smoke:ok")

context_map/__tests__/test_checker_frescura.py

@@ -0,0 +1,122 @@
+"""Tests de la señal de frescura del contexto (R1, auditoría 2026-08-14).
+
+Verifica que ``check`` (y por tanto ``refresh``) detecta actividad posterior
+al último build: commits git y sesiones de Hermes sin importar.
+"""
+
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+from context_map.domain.analysis.checker import (
+    analizar_readiness,
+    _sesiones_posteriores,
+    _ultima_actividad,
+)
+
+
+def _hacer_repo(tmp_path, con_build: bool = True, con_git: bool = True) -> str:
+    """Crea un mini proyecto con ``.context-map/state/last_build.json``.
+
+    Args:
+        tmp_path: Fixture de pytest con directorio temporal.
+        con_build (bool): Si se crea el last_build.json.
+        con_git (bool): Si se crea la carpeta .git.
+
+    Returns:
+        str: Ruta del mini proyecto.
+    """
+    ctx = tmp_path / ".context-map" / "state"
+    ctx.mkdir(parents=True)
+    if con_build:
+        (ctx / "last_build.json").write_text(
+            json.dumps({"clean": False, "manuales_preservadas": 0,
+                        "timestamp": "2000-01-01T00:00:00"}),
+            encoding="utf-8",
+        )
+    if con_git:
+        (tmp_path / ".git").mkdir(exist_ok=True)
+    return str(tmp_path)
+
+
+def _sesion(fecha_inicio: str) -> SimpleNamespace:
+    """Crea una sesión fake de Hermes con la fecha de inicio dada.
+
+    Args:
+        fecha_inicio (str): Timestamp (epoch o ISO) de inicio de la sesión.
+
+    Returns:
+        SimpleNamespace: Sesión mínima compatible con el modelo.
+    """
+    return SimpleNamespace(fecha_inicio=fecha_inicio)
+
+
+def test_ultima_actividad_detecta_commit_posterior_al_build(tmp_path, monkeypatch):
+    """Si hay un commit posterior al last_build, la señal avisa."""
+    ruta = _hacer_repo(tmp_path)
+
+    def _fake_git(_ruta, args):  # noqa: ANN001
+        if args and args[0] == "log":
+            return "1800000000"  # epoch posterior al build (2000-01-01)
+        return ""
+
+    monkeypatch.setattr("context_map.domain.analysis.checker._ejecutar_git", _fake_git)
+    monkeypatch.setattr("context_map.domain.analysis.checker.leer_sesiones", lambda *_: [])
+    actividad = _ultima_actividad(ruta)
+    assert actividad["commits_posteriores"] > 0
+    assert "commit" in actividad["aviso"].lower()
+
+
+def test_check_avisa_con_sesiones_sin_importar(tmp_path, monkeypatch):
+    """Si hay sesiones de Hermes posteriores al build, la señal avisa."""
+    ruta = _hacer_repo(tmp_path)
+
+    def _fake_git(_ruta, args):  # noqa: ANN001
+        return ""
+
+    def _fake_leer(db_path=None, limite=None):  # noqa: ANN001
+        return [_sesion("1800000000"), _sesion("1800000000"), _sesion("1800000000")]
+
+    monkeypatch.setattr("context_map.domain.analysis.checker._ejecutar_git", _fake_git)
+    monkeypatch.setattr("context_map.domain.analysis.checker.leer_sesiones", _fake_leer)
+    resultado = analizar_readiness(ruta)
+    assert any("sin importar" in s for s in resultado.sugerencias)
+
+
+def test_check_sin_actividad_no_avisa(tmp_path, monkeypatch):
+    """Sin commits ni sesiones posteriores, no hay falso aviso."""
+    ruta = _hacer_repo(tmp_path)
+
+    def _fake_git(_ruta, args):  # noqa: ANN001
+        return ""
+
+    def _fake_leer(db_path=None, limite=None):  # noqa: ANN001
+        return [_sesion("100")]  # anterior al build
+
+    monkeypatch.setattr("context_map.domain.analysis.checker._ejecutar_git", _fake_git)
+    monkeypatch.setattr("context_map.domain.analysis.checker.leer_sesiones", _fake_leer)
+    resultado = analizar_readiness(ruta)
+    assert not any("sin importar" in s for s in resultado.sugerencias)
+
+
+def test_sesiones_posteriores_cuenta_solo_las_recientes(tmp_path, monkeypatch):
+    """Cuenta sesiones cuya fecha de inicio supera el timestamp del build."""
+    ruta = _hacer_repo(tmp_path)
+
+    def _fake_leer(db_path=None, limite=None):  # noqa: ANN001
+        return [
+            _sesion("1800000000"),  # posterior a 2000-01-01
+            _sesion("1800000000"),
+            _sesion("100"),         # anterior al build
+        ]
+
+    monkeypatch.setattr("context_map.domain.analysis.checker.leer_sesiones", _fake_leer)
+    assert _sesiones_posteriores(ruta) == 2
+
+
+def test_sin_build_previo_avisa_nunca_build(tmp_path):
+    """Si no existe last_build.json, el aviso indica que nunca se ha construido."""
+    ruta = _hacer_repo(tmp_path, con_build=False)
+    actividad = _ultima_actividad(ruta)
+    assert "nunca" in actividad["aviso"].lower()

context_map/__tests__/test_cli.py

@@ -0,0 +1,134 @@
+"""Pruebas unitarias para el parser principal del CLI y despacho de comandos."""
+
+from __future__ import annotations
+
+import argparse
+
+from context_map.application.cli.parser import create_parser
+
+
+def test_cli_parser_defaults() -> None:
+    """Verifica que el parser principal cree los subcomandos esperados."""
+    parser = create_parser()
+    assert isinstance(parser, argparse.ArgumentParser)
+
+    # Test parser para comando 'check'
+    args = parser.parse_args(["check", "."])
+    assert args.cmd == "check"
+    assert args.target == "."
+
+    # Test parser para comando 'build'
+    args_build = parser.parse_args(["build", "--clean", "--brief"])
+    assert args_build.cmd == "build"
+    assert args_build.clean is True
+    assert args_build.brief is True
+
+    # Test parser para comando 'scan'
+    args_scan = parser.parse_args(["scan", "."])
+    assert args_scan.cmd == "scan"
+    assert args_scan.target == "."
+
+
+def test_cli_parser_auto_mode() -> None:
+    """Verifica los flags por defecto del comando auto."""
+    parser = create_parser()
+    args_auto = parser.parse_args(["auto", ".", "--project", "TestApp"])
+    assert args_auto.cmd == "auto"
+    assert args_auto.target == "."
+    assert args_auto.project == "TestApp"
+
+
+def test_aviso_pre_actualizacion_contiene_comando(monkeypatch) -> None:
+    """El aviso pre-refresh informa de la versión nueva y el comando de actualización."""
+    import context_map.infrastructure.version_check as vc
+    from context_map.infrastructure.version_check import aviso_pre_actualizacion
+
+    monkeypatch.setattr(vc, "hay_actualizacion", lambda force=False: (True, "1.4.0", "1.5.0"))
+    msg = aviso_pre_actualizacion()
+    assert "DESACTUALIZADO" in msg
+    assert "1.5.0" in msg
+    assert "uv tool install" in msg
+    assert "--with" in msg  # incluye el SDK de MCP
+
+    monkeypatch.setattr(vc, "hay_actualizacion", lambda force=False: (False, "1.5.0", "1.5.0"))
+    assert aviso_pre_actualizacion() == ""
+
+
+def test_refresh_imprime_aviso_pre_actualizacion(monkeypatch, capsys) -> None:
+    """El refresh verifica la versión del PROGRAMA antes de actualizar el CONTEXTO."""
+    import context_map.infrastructure.version_check as vc
+    from context_map.application.commands import refresh as refresh_mod
+    from context_map.application.commands.refresh import cmd_refresh
+
+    # No ejecutar scan/build/check reales en el test
+    monkeypatch.setattr(refresh_mod, "cmd_scan", lambda args: None)
+    monkeypatch.setattr(refresh_mod, "cmd_build", lambda args: None)
+    monkeypatch.setattr(refresh_mod, "cmd_check", lambda args: None)
+    # Hay una actualización pendiente → debe avisarse al inicio
+    monkeypatch.setattr(vc, "hay_actualizacion", lambda force=False: (True, "1.4.0", "1.5.0"))
+
+    args = argparse.Namespace(target=".", project="Demo", quiet=False, mode="hierarchical")
+    cmd_refresh(args)
+    out = capsys.readouterr().out
+
+    assert "DESACTUALIZADO" in out, "El refresh no avisó de la actualización pendiente"
+    assert "1.5.0" in out
+    # El aviso aparece ANTES del resultado del refresh
+    assert out.index("DESACTUALIZADO") < out.index("[refresh] [OK]")
+
+
+def test_refresh_importa_sesiones_automatico(monkeypatch, capsys) -> None:
+    """El refresh importa las sesiones recientes de Hermes (memoria viva automática)."""
+    import argparse
+
+    from context_map.application.commands import refresh as refresh_mod
+    from context_map.application.commands.refresh import cmd_refresh
+
+    monkeypatch.setattr(refresh_mod, "cmd_scan", lambda args: None)
+    monkeypatch.setattr(refresh_mod, "cmd_build", lambda args: None)
+    monkeypatch.setattr(refresh_mod, "cmd_check", lambda args: None)
+
+    llamado: dict = {}
+
+    def _fake_importar_sesiones(**kwargs):
+        llamado.update(kwargs)
+        return 3
+
+    monkeypatch.setattr(
+        "context_map.infrastructure.integrations.hermes.importar_sesiones",
+        _fake_importar_sesiones,
+    )
+
+    args = argparse.Namespace(target=".", project="Demo", quiet=False, mode="hierarchical")
+    cmd_refresh(args)
+    out = capsys.readouterr().out
+
+    # Se importan las 5 sesiones más recientes y los eventos van al raw del proyecto
+    assert llamado.get("limite") == 5
+    assert "events.jsonl" in llamado.get("output_path", "")
+    assert "3 evento(s) de sesiones importados" in out
+
+
+def test_refresh_importar_sesiones_tolerante(monkeypatch, capsys) -> None:
+    """Si la BD de sesiones no existe, el refresh NO se rompe (aviso y sigue)."""
+    import argparse
+
+    from context_map.application.commands import refresh as refresh_mod
+    from context_map.application.commands.refresh import cmd_refresh
+
+    monkeypatch.setattr(refresh_mod, "cmd_scan", lambda args: None)
+    monkeypatch.setattr(refresh_mod, "cmd_build", lambda args: None)
+    monkeypatch.setattr(refresh_mod, "cmd_check", lambda args: None)
+
+    def _fake_importar_sesiones(**kwargs):
+        raise FileNotFoundError("sin BD de sesiones")
+
+    monkeypatch.setattr(
+        "context_map.infrastructure.integrations.hermes.importar_sesiones",
+        _fake_importar_sesiones,
+    )
+
+    args = argparse.Namespace(target=".", project="Demo", quiet=False, mode="hierarchical")
+    cmd_refresh(args)  # no debe lanzar excepción
+    out = capsys.readouterr().out
+    assert "[refresh] [OK]" in out, "El refresh se rompió por la importación de sesiones"