@saulwade/swl-ses 1.6.1 → 1.6.5

package/scripts/lib/schema-version.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * scripts/lib/schema-version.js
+ *
+ * Helper de compatibilidad de schemas JSON aplicando reglas backward/forward
+ * del libro "Designing Data-Intensive Applications" de Martin Kleppmann
+ * (Capítulo 4, "Encoding and Evolution", p.112).
+ *
+ * Reglas implementadas (cita textual del libro):
+ *
+ *   "Backward compatibility — Newer code can read data that was written by
+ *    older code.
+ *
+ *    Forward compatibility — Older code can read data that was written by
+ *    newer code."
+ *
+ * Aplicado a SWL: cuando un schema evoluciona, el helper indica si un
+ * documento dado puede leerse con el schema dado y bajo qué modalidad
+ * de compatibilidad.
+ *
+ * Convenciones SemVer asumidas para $schemaVersion:
+ *   - MAJOR (X.0.0): breaking change (renombre, cambio de tipo, eliminación)
+ *   - MINOR (1.X.0): campo nuevo opcional, enum value nuevo
+ *   - PATCH (1.0.X): clarificación de descripción, sin cambio estructural
+ *
+ * Skill relacionado: proceso-ddia-fundamentos § Schema Evolution.
+ * ADR: 0026 — Versionado de schemas JSON con $schemaVersion.
+ */
+
+/**
+ * Parsea un string SemVer "MAJOR.MINOR.PATCH" a tupla numérica.
+ * @param {string} version
+ * @returns {[number, number, number] | null}
+ */
+function parsearVersion(version) {
+  if (typeof version !== 'string') return null;
+  const m = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!m) return null;
+  return [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)];
+}
+
+/**
+ * Verifica si un documento es compatible con un schema según sus $schemaVersion.
+ *
+ * @param {object} documento - Documento JSON con propiedad opcional $schemaVersion
+ * @param {object} schema - JSON Schema con propiedad opcional $schemaVersion
+ * @returns {{
+ *   compatible: boolean,
+ *   modo: "none" | "backward" | "forward" | "incompatible",
+ *   advertencias: string[]
+ * }}
+ *
+ * Casos:
+ *   - Ambos sin $schemaVersion → { compatible: true, modo: "none", advertencias: [warning] }
+ *   - Documento sin, schema con  → { compatible: true, modo: "forward", advertencias: [warning] }
+ *   - Doc 1.0.0 vs Schema 1.0.0  → { compatible: true, modo: "none" }
+ *   - Doc 1.0.0 vs Schema 1.1.0  → { compatible: true, modo: "forward" } (dato viejo + código nuevo)
+ *   - Doc 1.1.0 vs Schema 1.0.0  → { compatible: true, modo: "backward" } (dato nuevo + código viejo)
+ *   - Doc 2.0.0 vs Schema 1.0.0  → { compatible: false, modo: "incompatible" } (MAJOR rompe)
+ *   - Doc 1.0.0 vs Schema 2.0.0  → { compatible: false, modo: "incompatible" }
+ *   - Versión malformada         → { compatible: false, modo: "incompatible", advertencias: [error] }
+ */
+function verificarCompatibilidad(documento, schema) {
+  const advertencias = [];
+
+  const docVerStr = documento && documento.$schemaVersion;
+  const schVerStr = schema && schema.$schemaVersion;
+
+  if (!docVerStr && !schVerStr) {
+    return {
+      compatible: true,
+      modo: 'none',
+      advertencias: [
+        'Ni documento ni schema declaran $schemaVersion. Compatibilidad asumida pero no verificable.',
+      ],
+    };
+  }
+
+  if (!docVerStr && schVerStr) {
+    return {
+      compatible: true,
+      modo: 'forward',
+      advertencias: [
+        `Documento sin $schemaVersion contra schema ${schVerStr}. Asumiendo forward-compat (código nuevo lee dato viejo sin versión).`,
+      ],
+    };
+  }
+
+  if (docVerStr && !schVerStr) {
+    return {
+      compatible: false,
+      modo: 'incompatible',
+      advertencias: [
+        `Documento declara $schemaVersion ${docVerStr} pero schema no la declara. Schema debe actualizarse a $schemaVersion para validación correcta.`,
+      ],
+    };
+  }
+
+  const docVer = parsearVersion(docVerStr);
+  const schVer = parsearVersion(schVerStr);
+
+  if (!docVer) {
+    return {
+      compatible: false,
+      modo: 'incompatible',
+      advertencias: [`Documento $schemaVersion malformada: "${docVerStr}". Debe ser MAJOR.MINOR.PATCH (ej: "1.0.0").`],
+    };
+  }
+  if (!schVer) {
+    return {
+      compatible: false,
+      modo: 'incompatible',
+      advertencias: [`Schema $schemaVersion malformada: "${schVerStr}". Debe ser MAJOR.MINOR.PATCH (ej: "1.0.0").`],
+    };
+  }
+
+  const [docMaj, docMin] = docVer;
+  const [schMaj, schMin] = schVer;
+
+  // MAJOR distinto → incompatible (regla DDIA Cap 4: MAJOR es breaking)
+  if (docMaj !== schMaj) {
+    return {
+      compatible: false,
+      modo: 'incompatible',
+      advertencias: [
+        `MAJOR diferente: documento ${docVerStr} vs schema ${schVerStr}. ` +
+        `Cambios MAJOR son breaking por convención SemVer. Migración explícita requerida.`,
+      ],
+    };
+  }
+
+  // Mismo MAJOR.MINOR → compatible total (PATCH no afecta estructura)
+  if (docMin === schMin) {
+    return { compatible: true, modo: 'none', advertencias: [] };
+  }
+
+  // Documento MINOR menor que schema → forward (código nuevo lee dato viejo)
+  if (docMin < schMin) {
+    return {
+      compatible: true,
+      modo: 'forward',
+      advertencias: [
+        `Documento ${docVerStr} más antiguo que schema ${schVerStr}. ` +
+        `Forward-compat: código nuevo debe ignorar campos nuevos ausentes en dato viejo.`,
+      ],
+    };
+  }
+
+  // Documento MINOR mayor que schema → backward (código viejo lee dato nuevo)
+  return {
+    compatible: true,
+    modo: 'backward',
+    advertencias: [
+      `Documento ${docVerStr} más nuevo que schema ${schVerStr}. ` +
+      `Backward-compat: código viejo debe ignorar campos desconocidos en dato nuevo.`,
+    ],
+  };
+}
+
+module.exports = {
+  parsearVersion,
+  verificarCompatibilidad,
+};

package/scripts/mcp-orchestrator.py

@@ -31,8 +31,8 @@ from pathlib import Path
 from typing import Any
 
 # Importar helper compartido sin convertir scripts/ en paquete.
-sys.path.insert(0, str(Path(__file__).resolve().parent / 'lib'))
-from mcp_config import cargar_config_mcp  # noqa: E402
+sys.path.insert(0, str(Path(__file__).resolve().parent / "lib"))
+from mcp_config import build_stdio_env, cargar_config_mcp  # noqa: E402
 
 # ---------------------------------------------------------------------------
 # Dependencias — raw mcp SDK
@@ -41,6 +41,7 @@ try:
     from mcp import ClientSession
     from mcp.client.stdio import stdio_client, StdioServerParameters
     from mcp.client.sse import sse_client
+
     HAS_MCP = True
 except ImportError:
     HAS_MCP = False
@@ -49,8 +50,8 @@ except ImportError:
 # Constantes
 # ---------------------------------------------------------------------------
 
-TIMEOUT_S           = 12
-SNAPSHOT_FILE       = Path('.planning') / 'mcp-snapshot.json'
+TIMEOUT_S = 12
+SNAPSHOT_FILE = Path(".planning") / "mcp-snapshot.json"
 
 # ---------------------------------------------------------------------------
 # Carga de config — delega a scripts/lib/mcp_config.py para deep merge
@@ -63,13 +64,9 @@ def _cargar_config(cwd: Path, config_path: str | None = None) -> dict:
     return cargar_config_mcp(cwd, config_path)
 
 
-def _build_env(cfg: dict) -> dict | None:
-    extra = cfg.get('env') or {}
-    if not extra:
-        return None
-    merged = dict(os.environ)
-    merged.update(extra)
-    return merged
+def _build_env(cfg: dict) -> dict:
+    return build_stdio_env(cfg)
+
 
 # ---------------------------------------------------------------------------
 # Conexion async (igual que pool-manager, duplicada para zero-imports externos)
@@ -79,24 +76,24 @@ def _build_env(cfg: dict) -> dict | None:
 async def _probe_server(nombre: str, cfg: dict) -> dict:
     """Conecta a un servidor, devuelve su inventario completo de herramientas."""
     resultado: dict = {
-        'server':    nombre,
-        'transport': 'http' if 'url' in cfg else 'stdio',
-        'tools':     [],
-        'error':     None,
-        'estado':    'OK',
-        'duration_ms': 0,
+        "server": nombre,
+        "transport": "http" if "url" in cfg else "stdio",
+        "tools": [],
+        "error": None,
+        "estado": "OK",
+        "duration_ms": 0,
     }
     t0 = time.time()
     try:
-        if 'url' in cfg:
-            transport = sse_client(cfg['url'])
+        if "url" in cfg:
+            transport = sse_client(cfg["url"])
         else:
             env = _build_env(cfg)
             params = StdioServerParameters(
-                command=cfg['command'],
-                args=cfg.get('args', []),
+                command=cfg["command"],
+                args=cfg.get("args", []),
                 env=env,
-                cwd=cfg.get('cwd'),
+                cwd=cfg.get("cwd"),
             )
             transport = stdio_client(params)
 
@@ -104,21 +101,21 @@ async def _probe_server(nombre: str, cfg: dict) -> dict:
             async with ClientSession(read, write) as session:
                 await asyncio.wait_for(session.initialize(), timeout=TIMEOUT_S)
                 resp = await asyncio.wait_for(session.list_tools(), timeout=TIMEOUT_S)
-                resultado['tools'] = [
+                resultado["tools"] = [
                     {
-                        'name':        t.name,
-                        'description': t.description or '',
+                        "name": t.name,
+                        "description": t.description or "",
                     }
                     for t in (resp.tools or [])
                 ]
     except asyncio.TimeoutError:
-        resultado['error'] = f'Timeout ({TIMEOUT_S}s)'
-        resultado['estado'] = 'ERROR'
+        resultado["error"] = f"Timeout ({TIMEOUT_S}s)"
+        resultado["estado"] = "ERROR"
     except Exception as exc:
-        resultado['error'] = str(exc)
-        resultado['estado'] = 'ERROR'
+        resultado["error"] = str(exc)
+        resultado["estado"] = "ERROR"
     finally:
-        resultado['duration_ms'] = int((time.time() - t0) * 1000)
+        resultado["duration_ms"] = int((time.time() - t0) * 1000)
     return resultado
 
 
@@ -127,6 +124,7 @@ async def _probe_all(servers: dict) -> list:
     tareas = [_probe_server(n, c) for n, c in servers.items()]
     return list(await asyncio.gather(*tareas))
 
+
 # ---------------------------------------------------------------------------
 # Snapshot — persiste el ultimo estado conocido
 # ---------------------------------------------------------------------------
@@ -137,21 +135,23 @@ def _guardar_snapshot(cwd: Path, resultados: list) -> None:
     snap_file = cwd / SNAPSHOT_FILE
     snap_file.parent.mkdir(parents=True, exist_ok=True)
     snapshot = {
-        'generado': datetime.now(timezone.utc).isoformat(),
-        'servidores': resultados,
-        'resumen': {
-            'total':     len(resultados),
-            'activos':   sum(1 for r in resultados if r['estado'] == 'OK'),
-            'errores':   sum(1 for r in resultados if r['estado'] == 'ERROR'),
-            'tools':     sum(len(r['tools']) for r in resultados),
+        "generado": datetime.now(timezone.utc).isoformat(),
+        "servidores": resultados,
+        "resumen": {
+            "total": len(resultados),
+            "activos": sum(1 for r in resultados if r["estado"] == "OK"),
+            "errores": sum(1 for r in resultados if r["estado"] == "ERROR"),
+            "tools": sum(len(r["tools"]) for r in resultados),
         },
     }
     try:
-        tmp = snap_file.with_suffix('.tmp')
-        tmp.write_text(json.dumps(snapshot, ensure_ascii=False, indent=2), encoding='utf-8')
+        tmp = snap_file.with_suffix(".tmp")
+        tmp.write_text(
+            json.dumps(snapshot, ensure_ascii=False, indent=2), encoding="utf-8"
+        )
         os.replace(tmp, snap_file)
     except Exception as exc:
-        sys.stderr.write(f'[mcp-orchestrator] No se pudo guardar snapshot: {exc}\n')
+        sys.stderr.write(f"[mcp-orchestrator] No se pudo guardar snapshot: {exc}\n")
 
 
 def _cargar_snapshot(cwd: Path) -> dict | None:
@@ -159,10 +159,11 @@ def _cargar_snapshot(cwd: Path) -> dict | None:
     if not snap_file.exists():
         return None
     try:
-        return json.loads(snap_file.read_text(encoding='utf-8'))
+        return json.loads(snap_file.read_text(encoding="utf-8"))
     except Exception:
         return None
 
+
 # ---------------------------------------------------------------------------
 # Telemetria opcional (importa mcp-telemetry si esta disponible)
 # ---------------------------------------------------------------------------
@@ -171,16 +172,18 @@ def _cargar_snapshot(cwd: Path) -> dict | None:
 def _registrar_traza_discovery(cwd: Path, resumen: dict) -> None:
     """Registra una traza del discovery si mcp-telemetry esta disponible."""
     try:
-        sys.path.insert(0, str(cwd / 'scripts'))
+        sys.path.insert(0, str(cwd / "scripts"))
         from mcp_telemetry import registrar_traza  # type: ignore
+
         registrar_traza(
-            cwd       = cwd,
-            nombre    = 'mcp:discovery',
-            atributos = resumen,
-            estado    = 'OK' if resumen.get('errores', 0) == 0 else 'ERROR',
+            cwd=cwd,
+            nombre="mcp:discovery",
+            atributos=resumen,
+            estado="OK" if resumen.get("errores", 0) == 0 else "ERROR",
         )
     except ImportError:
-        pass   # mcp-telemetry no disponible — silencioso
+        pass  # mcp-telemetry no disponible — silencioso
+
 
 # ---------------------------------------------------------------------------
 # Subcomandos
@@ -188,87 +191,100 @@ def _registrar_traza_discovery(cwd: Path, resumen: dict) -> None:
 
 
 async def cmd_status(servers: dict, cwd: Path, as_json: bool, con_traza: bool) -> None:
-    out        = sys.stdout.write
+    out = sys.stdout.write
     resultados = await _probe_all(servers)
     _guardar_snapshot(cwd, resultados)
 
     resumen = {
-        'total':   len(resultados),
-        'activos': sum(1 for r in resultados if r['estado'] == 'OK'),
-        'errores': sum(1 for r in resultados if r['estado'] == 'ERROR'),
-        'tools':   sum(len(r['tools']) for r in resultados),
+        "total": len(resultados),
+        "activos": sum(1 for r in resultados if r["estado"] == "OK"),
+        "errores": sum(1 for r in resultados if r["estado"] == "ERROR"),
+        "tools": sum(len(r["tools"]) for r in resultados),
     }
 
     if con_traza:
         _registrar_traza_discovery(cwd, resumen)
 
     if as_json:
-        out(json.dumps({'resumen': resumen, 'servidores': resultados},
-                       ensure_ascii=False, indent=2) + '\n')
+        out(
+            json.dumps(
+                {"resumen": resumen, "servidores": resultados},
+                ensure_ascii=False,
+                indent=2,
+            )
+            + "\n"
+        )
         return
 
-    out('\nEstado de servidores MCP:\n')
-    out('-' * 68 + '\n')
+    out("\nEstado de servidores MCP:\n")
+    out("-" * 68 + "\n")
     for r in resultados:
-        estado = r['estado']
-        tools  = len(r['tools'])
-        ms     = r['duration_ms']
-        trans  = r['transport']
-        err    = f'  -- {r["error"]}' if r['error'] else ''
-        out(f'  {r["server"]:<28} {estado:<5} {tools:>3} tools  {ms:>5}ms  [{trans}]{err}\n')
-    out('\n')
-    out(f'  Total: {resumen["total"]} servidores, {resumen["activos"]} activos, '
-        f'{resumen["tools"]} herramientas disponibles\n')
-
-
-async def cmd_discover(servers: dict, cwd: Path, as_json: bool, con_traza: bool) -> None:
-    out        = sys.stdout.write
+        estado = r["estado"]
+        tools = len(r["tools"])
+        ms = r["duration_ms"]
+        trans = r["transport"]
+        err = f'  -- {r["error"]}' if r["error"] else ""
+        out(
+            f'  {r["server"]:<28} {estado:<5} {tools:>3} tools  {ms:>5}ms  [{trans}]{err}\n'
+        )
+    out("\n")
+    out(
+        f'  Total: {resumen["total"]} servidores, {resumen["activos"]} activos, '
+        f'{resumen["tools"]} herramientas disponibles\n'
+    )
+
+
+async def cmd_discover(
+    servers: dict, cwd: Path, as_json: bool, con_traza: bool
+) -> None:
+    out = sys.stdout.write
     resultados = await _probe_all(servers)
     _guardar_snapshot(cwd, resultados)
 
     if con_traza:
         resumen = {
-            'total':   len(resultados),
-            'activos': sum(1 for r in resultados if r['estado'] == 'OK'),
-            'errores': sum(1 for r in resultados if r['estado'] == 'ERROR'),
-            'tools':   sum(len(r['tools']) for r in resultados),
+            "total": len(resultados),
+            "activos": sum(1 for r in resultados if r["estado"] == "OK"),
+            "errores": sum(1 for r in resultados if r["estado"] == "ERROR"),
+            "tools": sum(len(r["tools"]) for r in resultados),
         }
         _registrar_traza_discovery(cwd, resumen)
 
     if as_json:
-        out(json.dumps(resultados, ensure_ascii=False, indent=2) + '\n')
+        out(json.dumps(resultados, ensure_ascii=False, indent=2) + "\n")
         return
 
     for r in resultados:
-        if r['error']:
+        if r["error"]:
             out(f'\n[{r["server"]}] ERROR: {r["error"]}\n')
             continue
         out(f'\n[{r["server"]}] {len(r["tools"])} herramientas:\n')
-        for t in r['tools']:
-            desc = t['description']
+        for t in r["tools"]:
+            desc = t["description"]
             if len(desc) > 72:
-                desc = desc[:69] + '...'
+                desc = desc[:69] + "..."
             out(f'  - {t["name"]:<32} {desc}\n')
 
 
 async def cmd_find_tool(servers: dict, keyword: str, as_json: bool) -> None:
-    out        = sys.stdout.write
+    out = sys.stdout.write
     resultados = await _probe_all(servers)
-    kw_lower   = keyword.lower()
+    kw_lower = keyword.lower()
 
     encontradas: list = []
     for r in resultados:
-        for t in r.get('tools', []):
-            if (kw_lower in t['name'].lower() or
-                    kw_lower in t['description'].lower()):
-                encontradas.append({
-                    'server': r['server'],
-                    'name':   t['name'],
-                    'description': t['description'],
-                })
+        for t in r.get("tools", []):
+            if kw_lower in t["name"].lower() or kw_lower in t["description"].lower():
+                encontradas.append(
+                    {
+                        "server": r["server"],
+                        "name": t["name"],
+                        "description": t["description"],
+                    }
+                )
 
     if as_json:
-        out(json.dumps(encontradas, ensure_ascii=False, indent=2) + '\n')
+        out(json.dumps(encontradas, ensure_ascii=False, indent=2) + "\n")
         return
 
     if not encontradas:
@@ -276,101 +292,107 @@ async def cmd_find_tool(servers: dict, keyword: str, as_json: bool) -> None:
         return
 
     out(f'\nHerramientas que coinciden con "{keyword}" ({len(encontradas)}):\n')
-    out('-' * 68 + '\n')
+    out("-" * 68 + "\n")
     for e in encontradas:
-        desc = e['description']
+        desc = e["description"]
         if len(desc) > 60:
-            desc = desc[:57] + '...'
+            desc = desc[:57] + "..."
         out(f'  [{e["server"]}]  {e["name"]:<28}  {desc}\n')
 
 
 def cmd_summary(cwd: Path, as_json: bool) -> None:
     """Muestra el ultimo snapshot guardado sin re-conectar a los servidores."""
-    out      = sys.stdout.write
+    out = sys.stdout.write
     snapshot = _cargar_snapshot(cwd)
 
     if not snapshot:
-        out('Sin snapshot disponible. Ejecuta primero: mcp-orchestrator.py status\n')
+        out("Sin snapshot disponible. Ejecuta primero: mcp-orchestrator.py status\n")
         return
 
     if as_json:
-        out(json.dumps(snapshot, ensure_ascii=False, indent=2) + '\n')
+        out(json.dumps(snapshot, ensure_ascii=False, indent=2) + "\n")
         return
 
-    generado = snapshot.get('generado', '?')[:19]
-    resumen  = snapshot.get('resumen', {})
-    out(f'\nResumen MCP (snapshot del {generado} UTC):\n')
-    out(f'  Servidores: {resumen.get("total", 0)} '
-        f'({resumen.get("activos", 0)} activos, {resumen.get("errores", 0)} con error)\n')
+    generado = snapshot.get("generado", "?")[:19]
+    resumen = snapshot.get("resumen", {})
+    out(f"\nResumen MCP (snapshot del {generado} UTC):\n")
+    out(
+        f'  Servidores: {resumen.get("total", 0)} '
+        f'({resumen.get("activos", 0)} activos, {resumen.get("errores", 0)} con error)\n'
+    )
     out(f'  Herramientas disponibles: {resumen.get("tools", 0)}\n')
-    out('\nDetalle por servidor:\n')
-    for r in snapshot.get('servidores', []):
-        estado = r.get('estado', '?')
-        tools  = len(r.get('tools', []))
-        ms     = r.get('duration_ms', 0)
+    out("\nDetalle por servidor:\n")
+    for r in snapshot.get("servidores", []):
+        estado = r.get("estado", "?")
+        tools = len(r.get("tools", []))
+        ms = r.get("duration_ms", 0)
         out(f'  {r["server"]:<28} {estado:<5} {tools:>3} tools  {ms:>5}ms\n')
 
+
 # ---------------------------------------------------------------------------
 # main()
 # ---------------------------------------------------------------------------
 
 
 def main() -> None:
-    if hasattr(sys.stdout, 'reconfigure'):
-        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
 
     if not HAS_MCP:
         sys.stderr.write(
-            '[mcp-orchestrator] ERROR: la libreria mcp no esta instalada.\n'
-            '[mcp-orchestrator] Ejecuta: pip install mcp\n'
+            "[mcp-orchestrator] ERROR: la libreria mcp no esta instalada.\n"
+            "[mcp-orchestrator] Ejecuta: pip install mcp\n"
         )
         sys.exit(1)
 
     parser = argparse.ArgumentParser(
-        description='Orquestador multi-servidor MCP para swl-ses'
+        description="Orquestador multi-servidor MCP para swl-ses"
     )
-    parser.add_argument('--json',  action='store_true', help='Salida en formato JSON')
-    parser.add_argument('--cwd',   default='.', help='Directorio raiz del proyecto')
-    parser.add_argument('--trace', action='store_true',
-                        help='Registrar resultado en .planning/traces/')
-    parser.add_argument('--config', default=None, help='Ruta al archivo de config MCP')
+    parser.add_argument("--json", action="store_true", help="Salida en formato JSON")
+    parser.add_argument("--cwd", default=".", help="Directorio raiz del proyecto")
+    parser.add_argument(
+        "--trace", action="store_true", help="Registrar resultado en .planning/traces/"
+    )
+    parser.add_argument("--config", default=None, help="Ruta al archivo de config MCP")
 
-    sub = parser.add_subparsers(dest='cmd')
+    sub = parser.add_subparsers(dest="cmd")
 
-    sub.add_parser('status',   help='Health check de todos los servidores MCP')
-    sub.add_parser('discover', help='Lista completa de herramientas por servidor')
+    sub.add_parser("status", help="Health check de todos los servidores MCP")
+    sub.add_parser("discover", help="Lista completa de herramientas por servidor")
 
-    p_find = sub.add_parser('find-tool', help='Busca herramienta por nombre o descripcion')
-    p_find.add_argument('keyword', help='Texto a buscar en nombre o descripcion')
+    p_find = sub.add_parser(
+        "find-tool", help="Busca herramienta por nombre o descripcion"
+    )
+    p_find.add_argument("keyword", help="Texto a buscar en nombre o descripcion")
 
-    sub.add_parser('summary',  help='Muestra el ultimo snapshot sin reconectar')
+    sub.add_parser("summary", help="Muestra el ultimo snapshot sin reconectar")
 
-    args    = parser.parse_args()
-    cwd     = Path(args.cwd).resolve()
-    as_json = bool(getattr(args, 'json', False))
-    traza   = bool(getattr(args, 'trace', False))
+    args = parser.parse_args()
+    cwd = Path(args.cwd).resolve()
+    as_json = bool(getattr(args, "json", False))
+    traza = bool(getattr(args, "trace", False))
 
-    if args.cmd == 'summary':
+    if args.cmd == "summary":
         cmd_summary(cwd, as_json)
         return
 
     servers = _cargar_config(cwd, args.config)
     if not servers:
         sys.stderr.write(
-            '[mcp-orchestrator] No se encontraron servidores MCP.\n'
+            "[mcp-orchestrator] No se encontraron servidores MCP.\n"
             '[mcp-orchestrator] Verifica la clave "mcpServers" en .claude/settings.json\n'
         )
         sys.exit(1)
 
-    if args.cmd == 'status':
+    if args.cmd == "status":
         asyncio.run(cmd_status(servers, cwd, as_json, traza))
-    elif args.cmd == 'discover':
+    elif args.cmd == "discover":
         asyncio.run(cmd_discover(servers, cwd, as_json, traza))
-    elif args.cmd == 'find-tool':
+    elif args.cmd == "find-tool":
         asyncio.run(cmd_find_tool(servers, args.keyword, as_json))
     else:
         parser.print_help()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()