context-map-ai 2.2.1__tar.gz → 2.3.0__tar.gz

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/.github/workflows/docs.yml

@@ -7,11 +7,13 @@ on:
       - main
 
 permissions:
-  contents: write
+  contents: read
 
 jobs:
   deploy:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
       - uses: actions/checkout@v4
 

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/.github/workflows/publish.yml

@@ -40,3 +40,17 @@ jobs:
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           skip-existing: true
+
+  github-release:
+    name: Create GitHub Release
+    needs: pypi-publish
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/.pre-commit-hooks.yaml

@@ -1,7 +1,7 @@
 - id: context-map
   name: ContextMap Auto Sync
   description: Escanea y actualiza automáticamente la bóveda de Obsidian y briefs de ContextMap antes de cada commit.
-  entry: ctxmap build --clean --brief --quiet
+  entry: python -m context_map.cli build --clean --brief --quiet
   language: python
   stages: [pre-commit]
   types: [python, markdown, yaml, json]

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/CHANGELOG.md

@@ -5,6 +5,31 @@ Todas las notas de versión y cambios destacables en este proyecto serán docume
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.3.0] — 2026-08-21
+
+### 🛡️ Novedades y Mejoras — Escáner de Secretos Avanzado, Entropía Shannon, Opt-Out Ollama & Automatización Release
+
+- **feat(`security`)**: Detección ampliada de credenciales con soporte para Slack tokens (`xoxb-`), Stripe keys (`sk_live_`, `sk_test_`), Twilio SIDs (`AC`, `SK`), SendGrid (`SG.`), npm access tokens (`npm_`) y webhooks de Discord.
+- **feat(`security`)**: Análisis matemático de alta entropía de Shannon (`calcular_entropia_shannon`) en asignaciones de variables sensibles para detectar llaves criptográficas no estructuradas.
+- **feat(`ollama`)**: Soporte de opt-out mediante flag `--no-ollama` en `ctxmap enrich` y variable de entorno `CTXMAP_NO_OLLAMA=1` para forzar análisis puramente offline y estático AST.
+- **feat(`ci/cd`)**: Creación automática de GitHub Releases (`softprops/action-gh-release@v2`) con notas generadas al publicar tags en `publish.yml`, y principio de mínimo privilegio en permisos de `docs.yml`.
+- **feat(`personal`)**: Soporte para la variable `CTXMAP_GDRIVE_ROOTS` en `personal sync` y optimización de búsqueda acotada de unidades en Windows.
+
+---
+
+## [2.2.2] — 2026-08-21
+
+### 🔧 Correcciones y Hardening — Saneamiento Técnico y Parche
+
+- **fix(`enrich`)**: Persistencia real en disco de los docstrings generados en `ctxmap enrich` vía `filepath.write_text` con formateo adecuado de indentación y soporte completo para flag `--dry-run` de previsualización sin alterar archivos.
+- **refactor(`complexity`/`cyclomatic`)**: Eliminación de la duplicación de código entre `domain/analysis/complexity.py` y `domain/analyzers/cyclomatic.py`. Consolidación unificada de métricas ciclomáticas de McCabe en `domain/analyzers/cyclomatic.py` (con soporte AST completo para `AsyncFor`, `AsyncWith`, `Assert`, `IfExp`, `BoolOp`).
+- **security(`adaptador`)**: Endurecimiento de `_es_generado_ctxmap` para exigir estrictamente el marcador `CONTEXTMAP:BEGIN` evitando falsos positivos con archivos de usuario.
+- **security(`hermes`)**: Parametrización segura de cláusulas `LIMIT ?` en SQLite para defensa en profundidad.
+- **devops(`pre-commit`)**: Actualización de `.pre-commit-hooks.yaml` para invocar el módulo local `python -m context_map.cli` en lugar del binario global.
+- **docs(`domain_extractor`)**: Corrección de docstrings clarificando análisis de frecuencia léxica local en lugar de TF-IDF.
+
+---
+
 ## [2.2.1] — 2026-08-21
 
 ### 🔧 Correcciones — Saneamiento de release

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: context-map-ai
-Version: 2.2.1
+Version: 2.3.0
 Summary: Mapa mental narrativo de proyectos para agentes de IA
 Project-URL: Homepage, https://github.com/kudawasama/ContextMap
 Project-URL: Repository, https://github.com/kudawasama/ContextMap
@@ -9,9 +9,12 @@ Author-email: kudawasama <cespedes.jac@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Keywords: agent,ai,context,mindmap,obsidian
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Spanish
+Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/context_map/__tests__/test_ecosistema.py

@@ -328,8 +328,10 @@ def test_adaptar_upgrade_memoria_viva_agents_generado() -> None:
         with open(agents_path, "w", encoding="utf-8") as f:
             f.write(
                 "# Instrucciones — Bot Demo\n\n"
-                "Este proyecto utiliza **ContextMap** para gobernanza de contexto.\n"
+                "<!-- CONTEXTMAP:BEGIN -->\n"
+                "Este proyecto utiliza ContextMap para gobernanza de contexto.\n"
                 "## 1. Protocolo de Inicio\n- Leer el brief\n"
+                "<!-- CONTEXTMAP:END -->\n"
             )
 
         eco = detectar_ecosistema(temp_dir)

context_map_ai-2.3.0/context_map/__tests__/test_enrich.py

@@ -0,0 +1,68 @@
+"""Pruebas unitarias para el comando ctxmap enrich y su persistencia en disco."""
+
+import argparse
+import ast
+import tempfile
+from pathlib import Path
+
+from context_map.application.commands.enrich import _formatear_docstring, cmd_enrich
+
+
+def test_formatear_docstring_simple() -> None:
+    """Verifica el formateo de un docstring simple de una sola línea."""
+    res = _formatear_docstring("Calcula el total de la orden.", "    ")
+    assert len(res) == 1
+    assert res[0] == '    """Calcula el total de la orden."""'
+
+
+def test_formatear_docstring_multilinea() -> None:
+    """Verifica el formateo de un docstring con múltiples líneas e indentación."""
+    doc = """Calcula el total.
+
+Args:
+    subtotal: Monto base.
+"""
+    res = _formatear_docstring(doc, "    ")
+    assert res[0] == '    """Calcula el total.'
+    assert "    Args:" in res
+    assert "        subtotal: Monto base." in res
+    assert res[-1] == '    """'
+
+
+def test_cmd_enrich_persiste_cambios_en_disco() -> None:
+    """Verifica que cmd_enrich escriba efectivamente el docstring generado en el archivo."""
+    codigo_original = "def sumar(a: int, b: int) -> int:\n    return a + b\n"
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        test_file = Path(tmpdir) / "matematica.py"
+        test_file.write_text(codigo_original, encoding="utf-8")
+
+        args = argparse.Namespace(path=str(test_file), model=None, dry_run=False)
+        ret = cmd_enrich(args)
+        assert ret == 0
+
+        contenido_nuevo = test_file.read_text(encoding="utf-8")
+        assert contenido_nuevo != codigo_original
+
+        # Validar que sea sintácticamente válido
+        tree = ast.parse(contenido_nuevo)
+        fn = tree.body[0]
+        assert isinstance(fn, ast.FunctionDef)
+        assert ast.get_docstring(fn) is not None
+        assert "sumar" in ast.get_docstring(fn).lower() or len(ast.get_docstring(fn)) > 0
+
+
+def test_cmd_enrich_dry_run_no_modifica_disco() -> None:
+    """Verifica que en modo --dry-run el archivo en disco permanezca intacto."""
+    codigo_original = "def restar(a: int, b: int) -> int:\n    return a - b\n"
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        test_file = Path(tmpdir) / "calculo.py"
+        test_file.write_text(codigo_original, encoding="utf-8")
+
+        args = argparse.Namespace(path=str(test_file), model=None, dry_run=True)
+        ret = cmd_enrich(args)
+        assert ret == 0
+
+        contenido_despues = test_file.read_text(encoding="utf-8")
+        assert contenido_despues == codigo_original

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/context_map/__tests__/test_enterprise_features.py

@@ -4,7 +4,7 @@ import tempfile
 
 from context_map.application.commands.hook import cmd_hook_install
 from context_map.core.storage.config_loader import load_project_config
-from context_map.domain.analysis.complexity import calcular_complejidad_archivo
+from context_map.domain.analyzers.cyclomatic import calcular_complejidad_archivo
 
 
 def test_hook_install_creates_pre_commit_script() -> None:

context_map_ai-2.3.0/context_map/__tests__/test_ollama.py

@@ -0,0 +1,29 @@
+"""Pruebas unitarias para el módulo context_map.infrastructure.integrations.ollama."""
+
+from context_map.infrastructure.integrations.ollama import OllamaLocalClient
+
+
+def test_ollama_client_init() -> None:
+    """Verifica la inicialización del cliente de Ollama local."""
+    client = OllamaLocalClient()
+    assert client.host == "http://localhost:11434"
+    assert client.hardware is not None
+    # Si no hay Ollama corriendo en el entorno de test, esta_disponible() debe retornar False sin lanzar excepción
+    disponible = client.esta_disponible()
+    assert isinstance(disponible, bool)
+
+
+def test_ollama_client_opt_out_parametro() -> None:
+    """Verifica que el parámetro opt_out desactive inmediatamente el cliente."""
+    client = OllamaLocalClient(opt_out=True)
+    assert client.opt_out is True
+    assert client.esta_disponible() is False
+    assert client.listar_modelos_instalados() == []
+
+
+def test_ollama_client_opt_out_entorno(monkeypatch) -> None:
+    """Verifica que la variable de entorno CTXMAP_NO_OLLAMA desactive el cliente."""
+    monkeypatch.setenv("CTXMAP_NO_OLLAMA", "1")
+    client = OllamaLocalClient()
+    assert client.opt_out is True
+    assert client.esta_disponible() is False

context_map_ai-2.3.0/context_map/__tests__/test_security.py

@@ -0,0 +1,65 @@
+"""Pruebas unitarias para el escáner de secretos y análisis de entropía de Shannon."""
+
+from context_map.domain.scanning.security import SecurityScanner, calcular_entropia_shannon
+
+
+def test_calcular_entropia_shannon() -> None:
+    """Verifica el cálculo de entropía de Shannon en cadenas repetitivas y aleatorias."""
+    assert calcular_entropia_shannon("") == 0.0
+    # Cadena de caracteres repetidos tiene entropía 0
+    assert calcular_entropia_shannon("aaaaaaaaaaaaaaaa") == 0.0
+    # Cadena pseudoaleatoria criptográfica tiene alta entropía (> 4.0)
+    entropia_alta = calcular_entropia_shannon("a8F9z!q2L#m9X$v1K@p8")
+    assert entropia_alta > 4.0
+
+
+def test_scanner_detecta_slack_y_stripe() -> None:
+    """Verifica la detección de tokens de Slack y Stripe."""
+    token_slack = "".join(["xo", "xb-", "123456789012-", "1234567890123-", "abcDEFghiJKLmnoPQR"])
+    token_stripe = "".join(["sk_", "live_", "51HzABC1234567890abcdefghijklmnOPQR"])
+    codigo = f"""
+    SLACK_BOT = "{token_slack}"
+    STRIPE_KEY = "{token_stripe}"
+    """
+    hallazgos = SecurityScanner.escanear_contenido(codigo, "app/config.py")
+    tipos = [h["tipo"] for h in hallazgos]
+    assert "Slack Token" in tipos
+    assert "Stripe API Key" in tipos
+
+
+def test_scanner_detecta_sendgrid_npm_twilio() -> None:
+    """Verifica la detección de SendGrid, npm y Twilio."""
+    token_sendgrid = "".join(["SG.", "abcdefghij1234567890_-.", "_-abcdefghijklmnopqrstuvwxyz0123456789012"])
+    token_npm = "".join(["npm_", "1234567890abcdefghijklmnopqrstuv"])
+    token_twilio = "".join(["AC", "1234567890abcdef1234567890abcdef"])
+    codigo = f"""
+    SENDGRID_API = "{token_sendgrid}"
+    NPM_AUTH = "{token_npm}"
+    TWILIO_SID = "{token_twilio}"
+    """
+    hallazgos = SecurityScanner.escanear_contenido(codigo, "services/auth.py")
+    tipos = [h["tipo"] for h in hallazgos]
+    assert "SendGrid API Key" in tipos
+    assert "npm Access Token" in tipos
+    assert "Twilio API Key or SID" in tipos
+
+
+def test_scanner_detecta_alta_entropia_generica() -> None:
+    """Verifica que asignaciones de alta entropía a variables sensibles sean advertidas."""
+    token_entropy = "".join(["9f8a7b6c5d", "4e3f2a1b0c", "9d8e7f6a5b", "4c3d2e1f0a"])
+    codigo = f'AUTH_TOKEN = "{token_entropy}"'
+    hallazgos = SecurityScanner.escanear_contenido(codigo, "sec/secrets.py")
+    tipos = [h["tipo"] for h in hallazgos]
+    assert any("Entropy" in t or "Token" in t for t in tipos)
+
+
+def test_scanner_ignora_lineas_dummy() -> None:
+    """Verifica que líneas con dummy, placeholder o example no disparen falsos positivos."""
+    token_anthropic = "".join(["sk-ant-", "api03-", "1234567890123456789012345678901234567890"])
+    token_example = "".join(["xo", "xb-", "123456789012-", "1234567890123-", "placeholder"])
+    codigo = f"""
+    # dummy_key = {token_anthropic}
+    EXAMPLE_TOKEN = "{token_example}"
+    """
+    hallazgos = SecurityScanner.escanear_contenido(codigo, "tests/mock.py")
+    assert len(hallazgos) == 0

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/context_map/application/cli/parser.py

@@ -60,6 +60,7 @@ def create_parser() -> argparse.ArgumentParser:
     s_enrich.add_argument("path", nargs="?", default=".", help="Ruta del archivo o directorio a enriquecer")
     s_enrich.add_argument("--model", default=None, help="Modelo de Ollama preferido (ej. qwen2.5-coder:1.5b)")
     s_enrich.add_argument("--dry-run", action="store_true", help="Solo muestra la vista previa sin modificar archivos")
+    s_enrich.add_argument("--no-ollama", action="store_true", help="Desactiva Ollama y utiliza exclusivamente inferencia AST offline")
 
     sub.add_parser("init", help="Crea estructura .context-map/")
 

context_map_ai-2.3.0/context_map/application/commands/enrich.py

@@ -0,0 +1,162 @@
+"""Comando `ctxmap enrich` para el enriquecimiento automático de código función por función.
+
+Analiza archivos Python mediante AST y genera docstrings formales en Español Técnico
+(Google Style) utilizando Ollama local si está disponible o inferencia AST estática.
+"""
+
+import argparse
+import ast
+from pathlib import Path
+
+from context_map.domain.analyzers.ast_summary import ASTSummaryExtractor
+from context_map.domain.health.hardware import evaluar_hardware_pc
+from context_map.infrastructure.integrations.ollama import OllamaLocalClient
+
+
+def _formatear_docstring(doc: str, indent: str) -> list[str]:
+    """Formatea un docstring garantizando comillas triples y la indentación adecuada.
+
+    Args:
+        doc: Contenido del docstring (puede o no traer comillas triples).
+        indent: Espacios de indentación que corresponden al cuerpo de la función.
+
+    Returns:
+        Lista de líneas listas para ser insertadas.
+    """
+    texto = doc.strip()
+    if texto.startswith('"""') and texto.endswith('"""'):
+        texto = texto[3:-3].strip()
+    elif texto.startswith("'''") and texto.endswith("'''"):
+        texto = texto[3:-3].strip()
+
+    lineas_doc = texto.splitlines()
+    if not lineas_doc:
+        return [f'{indent}""""""']
+
+    if len(lineas_doc) == 1:
+        return [f'{indent}"""{lineas_doc[0]}"""']
+
+    resultado = [f'{indent}"""{lineas_doc[0]}']
+    for linea in lineas_doc[1:]:
+        if linea.strip():
+            resultado.append(f"{indent}{linea}")
+        else:
+            resultado.append("")
+    resultado.append(f'{indent}"""')
+    return resultado
+
+
+def cmd_enrich(args: argparse.Namespace) -> int:
+    """Ejecuta el enriquecimiento de código función por función.
+
+    Args:
+        args: Argumentos de CLI (path, model, dry_run).
+
+    Returns:
+        Código de salida 0 (éxito) o 1 (error).
+    """
+    ruta_target = Path(args.path).resolve() if hasattr(args, "path") and args.path else Path(".").resolve()
+    dry_run = getattr(args, "dry_run", False)
+
+    modo_str = " (MODO PREVIEW / DRY-RUN)" if dry_run else ""
+    print(f"[enrich] Analizando directorio: {ruta_target}{modo_str}")
+
+    # 1. Diagnóstico de Hardware y RAM
+    hw = evaluar_hardware_pc()
+    print(f"[enrich] Hardware: {hw.mensaje_diagnostico}")
+
+    # 2. Inicializar cliente Ollama si es apto y no se solicitó opt-out
+    no_ollama = getattr(args, "no_ollama", False)
+    ollama_client: OllamaLocalClient | None = None
+    if hw.es_apto_para_ollama and not no_ollama:
+        client = OllamaLocalClient(
+            model_name=getattr(args, "model", None) or hw.modelo_recomendado,
+            opt_out=no_ollama,
+        )
+        if client.esta_disponible():
+            ollama_client = client
+            print(f"[enrich] Ollama local activo con modelo '{client.model_name}'")
+        else:
+            print("[enrich] Ollama no activo en localhost:11434 o desactivado. Se utiliza inferencia sintáctica AST offline.")
+    elif no_ollama:
+        print("[enrich] Ollama desactivado por flag --no-ollama. Se utiliza inferencia sintáctica AST offline.")
+
+    # 3. Recorrer archivos .py y enriquecer función por función
+    archivos_procesados = 0
+    funciones_enriquecidas = 0
+
+    archivos = [ruta_target] if ruta_target.is_file() else list(ruta_target.rglob("*.py"))
+
+    for filepath in archivos:
+        if any(part.startswith(".") or part in ("venv", "build", "dist", "__pycache__") for part in filepath.parts):
+            continue
+
+        try:
+            contenido = filepath.read_text(encoding="utf-8", errors="ignore")
+            tree = ast.parse(contenido)
+        except Exception:
+            continue
+
+        lineas = contenido.splitlines()
+
+        # Recolectar funciones sin docstring
+        nodos_funciones: list[ast.FunctionDef | ast.AsyncFunctionDef] = []
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if not ast.get_docstring(node) and node.body:
+                    nodos_funciones.append(node)
+
+        if not nodos_funciones:
+            archivos_procesados += 1
+            continue
+
+        # Ordenar de abajo hacia arriba por línea de inicio del cuerpo para insertar sin desfasar índices
+        nodos_funciones.sort(key=lambda n: n.body[0].lineno, reverse=True)
+        archivo_modificado = False
+
+        for node in nodos_funciones:
+            funciones_enriquecidas += 1
+            # Extraer código de la función
+            fn_code = "\n".join(lineas[node.lineno - 1 : node.end_lineno])
+
+            # Intentar inferencia con Ollama o Fallback AST
+            nuevo_doc = None
+            if ollama_client:
+                nuevo_doc = ollama_client.generar_docstring_funcion(node.name, fn_code)
+
+            if not nuevo_doc:
+                extractor = ASTSummaryExtractor(fn_code)
+                resumen = extractor.inferir_resumen()
+                nuevo_doc = resumen
+
+            # Determinar indentación del cuerpo de la función
+            primer_stmt_lineno = node.body[0].lineno  # 1-indexed
+            linea_cuerpo = lineas[primer_stmt_lineno - 1]
+            indent_cuerpo = linea_cuerpo[: len(linea_cuerpo) - len(linea_cuerpo.lstrip())]
+            if not indent_cuerpo:
+                # Fallback: indentación de la línea def + 4 espacios
+                linea_def = lineas[node.lineno - 1]
+                indent_def = linea_def[: len(linea_def) - len(linea_def.lstrip())]
+                indent_cuerpo = indent_def + "    "
+
+            bloque_docstring = _formatear_docstring(nuevo_doc, indent_cuerpo)
+
+            # Insertar en las líneas antes de la primera sentencia del cuerpo
+            idx_insercion = primer_stmt_lineno - 1
+            for offset, l_doc in enumerate(bloque_docstring):
+                lineas.insert(idx_insercion + offset, l_doc)
+
+            archivo_modificado = True
+            prefijo = "[dry-run] " if dry_run else ""
+            print(f"  · {prefijo}{filepath.name} :: {node.name}() -> Enriquecido con docstring")
+
+        if archivo_modificado and not dry_run:
+            nuevo_contenido = "\n".join(lineas)
+            if contenido.endswith("\n"):
+                nuevo_contenido += "\n"
+            filepath.write_text(nuevo_contenido, encoding="utf-8")
+
+        archivos_procesados += 1
+
+    print(f"[enrich] [OK] Finalizado: {archivos_procesados} archivos evaluados, {funciones_enriquecidas} funciones identificadas.")
+    return 0

{context_map_ai-2.2.1 → context_map_ai-2.3.0}/context_map/application/commands/personal.py

@@ -142,15 +142,38 @@ def _bases_por_defecto() -> list[str]:
         os.path.expanduser("~/Documents"),
         os.path.expanduser("~/Desktop"),
     ]
-    # Google Drive (Mi unidad) en cualquier letra de unidad montada
-    for letra in "CDEFGHIJKLMNOPQRSTUVWXYZ":
-        unidad = f"{letra}:"
-        if not os.path.isdir(unidad):
-            continue
-        mi_unidad = os.path.join(unidad, "Mi unidad")
-        if os.path.isdir(mi_unidad):
-            bases.append(os.path.join(mi_unidad, "Desarrollo y Proyectos"))
-            bases.append(mi_unidad)
+
+    # 1. Rutas configuradas explícitamente vía variable de entorno
+    gdrive_env = os.environ.get("CTXMAP_GDRIVE_ROOTS", "").strip()
+    if gdrive_env:
+        for r in gdrive_env.split(";" if ";" in gdrive_env else ","):
+            r_limpia = r.strip()
+            if r_limpia and os.path.isdir(r_limpia):
+                bases.append(r_limpia)
+        return bases
+
+    # 2. Rutas estándar conocidas de Google Drive
+    for ruta_estandar in [
+        os.path.expanduser("~/Google Drive/Mi unidad"),
+        os.path.expanduser("~/GoogleDrive/Mi unidad"),
+        "G:\\Mi unidad",
+        "H:\\Mi unidad",
+    ]:
+        if os.path.isdir(ruta_estandar):
+            bases.append(os.path.join(ruta_estandar, "Desarrollo y Proyectos"))
+            bases.append(ruta_estandar)
+
+    # 3. Búsqueda acotada en letras de unidad montadas en Windows si no se halló en las estándar
+    if os.name == "nt" and not any("Mi unidad" in b for b in bases):
+        for letra in "CDEFGHIJKLMNOPQRSTUVWXYZ":
+            unidad = f"{letra}:\\"
+            if not os.path.isdir(unidad):
+                continue
+            mi_unidad = os.path.join(unidad, "Mi unidad")
+            if os.path.isdir(mi_unidad):
+                bases.append(os.path.join(mi_unidad, "Desarrollo y Proyectos"))
+                bases.append(mi_unidad)
+
     return bases
 
 

context_map_ai-2.3.0/context_map/domain/analyzers/__init__.py

@@ -0,0 +1,31 @@
+"""Módulo de analizadores AST y de código estático de ContextMap."""
+
+from context_map.domain.analyzers.ast_audit import (
+    AlertaAuditoria,
+    AuditVisitor,
+    auditar_archivo_python,
+    auditar_proyecto_python,
+)
+from context_map.domain.analyzers.ast_summary import ASTSummaryExtractor
+from context_map.domain.analyzers.cyclomatic import (
+    MetricaComplejidadArchivo,
+    MetricaComplejidadFuncion,
+    MetricaFuncion,
+    analizar_archivo_ciclomatico,
+    calcular_complejidad_archivo,
+    calcular_complejidad_ciclomatica,
+)
+
+__all__ = [
+    "AlertaAuditoria",
+    "AuditVisitor",
+    "ASTSummaryExtractor",
+    "MetricaComplejidadArchivo",
+    "MetricaComplejidadFuncion",
+    "MetricaFuncion",
+    "analizar_archivo_ciclomatico",
+    "auditar_archivo_python",
+    "auditar_proyecto_python",
+    "calcular_complejidad_archivo",
+    "calcular_complejidad_ciclomatica",
+]