ratifact 1.0.0__py3-none-any.whl

ratifact/catalogo.py

@@ -0,0 +1,138 @@
+"""Catálogo de la memoria (ADR-022): id, tipo, título, estado y ruta de cada registro de .project/decisions,
+pending y tasks, leído del frontmatter en cada llamada. No se guarda nada en disco: sin índice, sin caché, sin
+watcher. Alimenta la resolución de ids de leer_documento, el listado de registros, los resultados de buscar y
+los pendientes abiertos de obtener_contexto."""
+from __future__ import annotations
+
+import re
+import unicodedata
+from pathlib import Path
+from typing import NamedTuple
+
+from ratifact.config import MEM, ErrorMemoria, _mem
+from ratifact.registros import _buscar_registro, _clave_id, _leer_registro, _normalizar_id
+from ratifact.vocabulario import CARPETAS_V1, DECISIONES, PENDIENTES, TAREAS
+
+# prefijo del id → (carpeta de la memoria, tipo)
+TIPOS = {"ADR": (DECISIONES, "decision"), "P": (PENDIENTES, "pending"), "T": (TAREAS, "task")}
+CARPETAS = {carpeta: prefijo for prefijo, (carpeta, _) in TIPOS.items()}
+# un id pedido con la carpeta v1 ("tareas/T-024.md") se resuelve igual (solo lectura, ADR-022)
+CARPETAS_ID = {**CARPETAS, **{v1: CARPETAS[v2] for v1, v2 in CARPETAS_V1.items() if v2 in CARPETAS}}
+
+
+class Registro(NamedTuple):
+    id: str
+    tipo: str
+    titulo: str
+    estado: str
+    ruta: str        # relativa al proyecto: ".project/<carpeta>/<archivo>"
+    fecha: str = ""  # fecha de creación del frontmatter (AAAA-MM-DD)
+
+
+def _registros_de(mem: Path, prefijo: str) -> list[Registro]:
+    carpeta, tipo = TIPOS[prefijo]
+    d = mem / carpeta
+    filas = []
+    for p in sorted(d.glob(f"{prefijo}-*.md"), key=lambda a: _clave_id(a.name)) if d.is_dir() else []:
+        if not re.match(rf"{prefijo}-\d+", p.name):
+            continue
+        meta, _ = _leer_registro(p)
+        id_ = _normalizar_id(meta.get("id") or re.match(rf"{prefijo}-\d+", p.name).group(0))
+        filas.append(Registro(id_, tipo, meta.get("title") or meta.get("topic", ""), meta.get("status", ""),
+                              f"{MEM}/{carpeta}/{p.name}", meta.get("date", "")))
+    return filas
+
+
+def _catalogo(proyecto: str) -> list[Registro]:
+    """Todos los registros del proyecto (decisiones, pendientes, tareas), cada tipo en orden numérico de id."""
+    mem = _mem(proyecto)
+    return [r for prefijo in TIPOS for r in _registros_de(mem, prefijo)]
+
+
+def _linea(r: Registro, separador: str = " ") -> str:
+    return f"{r.id} · {r.estado} · {r.titulo}{separador}({r.ruta})"
+
+
+TOPE_TEMA = 100   # caracteres del tema de un pendiente en el arranque; más largo se corta a 99 + "…"
+
+
+def _bloque_pendientes(proyecto: str) -> str:
+    """Pendientes abiertos para obtener_contexto (ADR-026): una línea por pendiente, en orden numérico de id, desde el
+    catálogo (sin extracto ni dueño). OPEN.md sigue en disco con su formato; el arranque ya no lo incluye."""
+    abiertos = [r for r in _registros_en(proyecto, "P") if r.estado == "open"]
+    lineas = [f"# Open items ({len(abiertos)})"]
+    for r in abiertos:
+        tema = r.titulo if len(r.titulo) <= TOPE_TEMA else r.titulo[:TOPE_TEMA - 1] + "…"
+        lineas.append(f"- {r.id} · {tema} ({r.fecha})")
+    if abiertos:
+        lineas.append(f'Detail: read_document("{proyecto}", "P-NNN")')
+    return "\n".join(lineas)
+
+
+def _id_de_ruta(ruta: str) -> str | None:
+    """Id que se pidió con una ruta que no existe: "T-24", "T-024.md", "tasks/T-024.md", ".project/tasks/T-024.md",
+    ".project/decisions/ADR-020-<slug equivocado>.md" (también con la carpeta v1: "tareas/T-024.md"). Solo si el resto
+    de la ruta apunta a la memoria (nada, una carpeta de registros, .project o .project/<carpeta de registros>) y el
+    prefijo es de un tipo conocido; así una ruta de código como "docs/T-001.md" o "src/T-1.java" nunca se resuelve a un registro."""
+    partes = Path(ruta.strip()).parts
+    if not partes:
+        return None
+    padre = partes[:-1]
+    if padre and padre[0] == MEM:
+        padre = padre[1:]
+    if len(padre) > 1 or (padre and padre[0] not in CARPETAS_ID):
+        return None
+    m = re.fullmatch(r"([A-Za-z]+-\d+)(-[^/]*)?(\.md)?", partes[-1])
+    id_ = _normalizar_id(m.group(1)) if m else ""
+    return id_ if id_.split("-")[0] in TIPOS else None
+
+
+def _resolver_id(proyecto: str, ruta: str) -> Path | None:
+    """Archivo real del registro al que se refiere `ruta` (que no existe), o None si `ruta` no tiene forma de id.
+    Solo lee, y solo dentro de la carpeta de memoria. Id desconocido → ErrorMemoria con el último id de su tipo."""
+    id_ = _id_de_ruta(ruta)
+    if id_ is None:
+        return None
+    prefijo = id_.split("-")[0]
+    mem = _mem(proyecto)
+    carpeta = mem / TIPOS[prefijo][0]
+    try:
+        return _buscar_registro(carpeta, id_)
+    except ErrorMemoria:
+        existentes = _registros_de(mem, prefijo)
+        if not existentes:
+            raise ErrorMemoria(f"{id_} does not exist; there are no records in {MEM}/{TIPOS[prefijo][0]} yet.")
+        raise ErrorMemoria(f"{id_} does not exist; the latest is {existentes[-1].id}.")
+
+
+def _es_carpeta_de_registros(carpeta: str) -> str | None:
+    """Prefijo si `carpeta` es .project/decisions|pending|tasks (con o sin "/" final)."""
+    partes = Path(carpeta.strip()).parts
+    return CARPETAS.get(partes[1]) if len(partes) == 2 and partes[0] == MEM else None
+
+
+def _registros_en(proyecto: str, prefijo: str) -> list[Registro]:
+    return _registros_de(_mem(proyecto), prefijo)
+
+
+TOPE_TITULOS = 5   # coincidencias por título que buscar muestra (el id exacto no cuenta)
+
+
+def _plano(texto: str) -> str:
+    """Sin acentos ni mayúsculas, para comparar títulos: "Navegación" → "navegacion"."""
+    return "".join(c for c in unicodedata.normalize("NFKD", texto) if not unicodedata.combining(c)).casefold()
+
+
+def _coincidencias(proyecto: str, texto: str) -> tuple[list[Registro], int]:
+    """Registros para buscar: primero el cuyo id es `texto` (en cualquier forma que acepte _normalizar_id), luego hasta
+    TOPE_TITULOS cuyo título contiene `texto` al inicio de una palabra (sin distinguir mayúsculas ni acentos: "id" no
+    coincide con "híbrido"; "asiento" sí con "Asientos"). Devuelve también cuántos títulos quedaron fuera del tope."""
+    buscado = _plano(texto.strip())
+    if not buscado:
+        return [], 0
+    objetivo = _normalizar_id(texto)
+    patron = re.compile(rf"(?<!\w){re.escape(buscado)}")
+    filas = _catalogo(proyecto)
+    exactos = [r for r in filas if r.id == objetivo]
+    titulos = [r for r in filas if r.id != objetivo and patron.search(_plano(r.titulo))]
+    return exactos + titulos[:TOPE_TITULOS], max(len(titulos) - TOPE_TITULOS, 0)

ratifact/cli.py

@@ -0,0 +1,67 @@
+"""Comando `ratifact` (ADR-032): `serve` (servidor MCP por stdio, lo que lanzan los clientes), `install` (configura
+los clientes MCP y /run-task, T-013), `report` (resumen del uso, antes analizar_uso.py), `doctor` (diagnóstico de solo
+lectura) y `upgrade` (paso explícito de ADR-029). `install` y `upgrade` sin `--apply` solo muestran el plan.
+`ratifact --version` muestra la versión."""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from ratifact import __version__
+
+
+def servidor():
+    """Carga los módulos de herramientas y prompts (sus decoradores los registran en `app.mcp`) y devuelve `mcp`."""
+    from ratifact import app, prompts  # noqa: F401
+    from ratifact import herramientas  # noqa: F401
+    return app.mcp
+
+
+def _parser() -> argparse.ArgumentParser:
+    from ratifact.informe import argumentos
+    ap = argparse.ArgumentParser(prog="ratifact", description="Project memory MCP server (ratifact).")
+    ap.add_argument("--version", action="version", version=f"ratifact {__version__}")
+    sub = ap.add_subparsers(dest="comando", metavar="{serve,install,report,doctor,upgrade}")
+    sub.required = True
+    sub.add_parser("serve", help="run the MCP server over stdio (what the clients launch)")
+    from ratifact.clientes import NOMBRES
+    ins = sub.add_parser("install", help="configure the MCP clients found (Claude Desktop, Claude Code, Pi, Codex) "
+                                         "and link /run-task; shows the plan unless --apply")
+    modo_ins = ins.add_mutually_exclusive_group()
+    modo_ins.add_argument("--apply", action="store_true", help="execute the plan (with backups)")
+    modo_ins.add_argument("--dry-run", action="store_true", help="only show the plan (the default)")
+    ins.add_argument("--client", choices=list(NOMBRES), help="configure only this client")
+    argumentos(sub.add_parser("report", help="usage summary from the telemetry log"))
+    sub.add_parser("doctor", help="read-only diagnosis of the installation; exit 1 if there are pending actions")
+    up = sub.add_parser("upgrade", help="move memories to .ratifact/ and projects.json to English keys; "
+                                        "shows the plan unless --apply")
+    modo = up.add_mutually_exclusive_group()
+    modo.add_argument("--apply", action="store_true", help="execute the plan (close every client first)")
+    modo.add_argument("--dry-run", action="store_true", help="only show the plan (the default)")
+    return ap
+
+
+def main(argv: list[str] | None = None) -> None:
+    a = _parser().parse_args(argv)
+    if a.comando == "serve":
+        import atexit
+        from ratifact import build, procesos
+        vigilante = build.iniciar()     # ADR-037: build id and fingerprint of the code this process loads
+        atexit.register(procesos.desregistrar, procesos.registrar(vigilante))     # ADR-038: for doctor
+        servidor().run()
+    elif a.comando == "report":
+        from ratifact import informe
+        informe.main(a=a)
+    elif a.comando == "install":
+        from ratifact import instalar
+        sys.exit(instalar.main(aplicar=a.apply, cliente=a.client))
+    elif a.comando == "doctor":
+        from ratifact import doctor
+        sys.exit(doctor.main())
+    else:
+        from ratifact import upgrade
+        sys.exit(upgrade.main(aplicar=a.apply))
+
+
+if __name__ == "__main__":
+    main()

ratifact/clientes.py

@@ -0,0 +1,206 @@
+"""MCP clients that `ratifact install` configures and `ratifact doctor` reports (T-013): Claude Desktop, Claude Code
+(`claude mcp add --scope user` if the `claude` executable exists, otherwise ~/.claude.json), Pi and Codex. Each ends with
+the server key `ratifact`, the absolute path of the installed executable, args ["serve"] and no environment variables;
+an old `memoria-proyectos` entry is replaced (never both). Planning only reads; `aplicar` writes through
+ratifact.archivos (validation, backup, atomic replace)."""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable
+
+from ratifact import clientes_toml
+from ratifact.archivos import ErrorInstalacion, escribir_validado, leer_json, respaldar, texto_json
+
+CLAVE, CLAVE_VIEJA = clientes_toml.CLAVE, clientes_toml.CLAVE_VIEJA
+CONFIGURADO, VIEJA = "configured with ratifact", "old configuration"
+SIN_CONFIGURAR, NO_ENCONTRADO = "not configured", "not found"
+NOMBRES = {"claude-desktop": "Claude Desktop", "claude-code": "Claude Code", "pi": "Pi", "codex": "Codex"}
+_BUSCAR = object()
+
+__all__ = ["ErrorInstalacion", "clientes", "planificar", "aplicar"]
+
+
+@dataclass
+class Cliente:
+    nombre: str
+    archivo: Path
+    encontrado: bool
+    formato: str = "json"                   # json | toml
+    cli: str | None = None                  # Claude Code: the `claude` executable, if it exists
+
+    @property
+    def titulo(self) -> str:
+        return NOMBRES[self.nombre]
+
+
+def _carpeta_desktop(home: Path) -> Path:
+    if sys.platform == "darwin":
+        return home / "Library" / "Application Support" / "Claude"
+    return home / ".config" / "Claude"
+
+
+def clientes(claude=_BUSCAR) -> list[Cliente]:
+    """The four clients, with whether they are installed on this machine (read at every call, from HOME)."""
+    home = Path.home()
+    claude = shutil.which("claude") if claude is _BUSCAR else claude
+    desktop = _carpeta_desktop(home)
+    return [
+        Cliente("claude-desktop", desktop / "claude_desktop_config.json", desktop.is_dir()),
+        Cliente("claude-code", home / ".claude.json",
+                bool(claude) or (home / ".claude.json").exists() or (home / ".claude").is_dir(), cli=claude),
+        Cliente("pi", home / ".pi" / "agent" / "mcp.json", (home / ".pi" / "agent").is_dir()),
+        Cliente("codex", home / ".codex" / "config.toml", (home / ".codex").is_dir(), formato="toml"),
+    ]
+
+
+@dataclass
+class PlanCliente:
+    cliente: Cliente
+    estado: str
+    error: str = ""
+    texto: str | None = None                # new content of the file (edit by file)
+    comandos: list[list[str]] = field(default_factory=list)      # `claude …` calls (edit by CLI)
+    descripcion: str = ""
+    ejecutable: str = ""
+
+    @property
+    def cambia(self) -> bool:
+        return self.texto is not None or bool(self.comandos)
+
+
+def estado_servidores(servidores, exe: str | None) -> str:
+    if not isinstance(servidores, dict):
+        return SIN_CONFIGURAR
+    if CLAVE_VIEJA in servidores:
+        return VIEJA
+    e = servidores.get(CLAVE)
+    if e is None:
+        return SIN_CONFIGURAR
+    ok = isinstance(e, dict) and e.get("args") == ["serve"] and not e.get("env") and (
+        e.get("command") == exe if exe else Path(str(e.get("command"))).name == "ratifact")
+    return CONFIGURADO if ok else VIEJA
+
+
+def _servidores(c: Cliente, datos: dict):
+    return datos.get("mcp_servers" if c.formato == "toml" else "mcpServers")
+
+
+def leer(c: Cliente) -> tuple[dict, str]:
+    """(parsed data, original text). ErrorInstalacion if the file cannot be parsed."""
+    if c.formato == "toml":
+        texto = c.archivo.read_text(encoding="utf-8") if c.archivo.exists() else ""
+        return clientes_toml.parsear(texto, str(c.archivo)), texto
+    return leer_json(c.archivo), c.archivo.read_text(encoding="utf-8") if c.archivo.exists() else ""
+
+
+def estado(c: Cliente, exe: str | None = None) -> str:
+    """configured with ratifact / old configuration / not configured / not found / error: … (doctor)."""
+    if not c.encontrado:
+        return NO_ENCONTRADO
+    try:
+        datos, _ = leer(c)
+    except ErrorInstalacion as e:
+        return f"error: {e}"
+    return estado_servidores(_servidores(c, datos), exe)
+
+
+def _entrada_json(c: Cliente, servidores: dict, exe: str) -> dict:
+    fuente = servidores.get(CLAVE) if CLAVE in servidores else servidores.get(CLAVE_VIEJA) or {}
+    extra = {k: v for k, v in (fuente if isinstance(fuente, dict) else {}).items()
+             if k not in ("type", "command", "args", "env")}
+    return {**({"type": "stdio"} if c.nombre == "claude-code" else {}), "command": exe, "args": ["serve"], **extra}
+
+
+def _reemplazar_json(c: Cliente, datos: dict, exe: str) -> dict:
+    """Same data with `ratifact` where the first of ratifact / memoria-proyectos was (or at the end)."""
+    servidores = datos.get("mcpServers") or {}
+    entrada, nuevos = _entrada_json(c, servidores, exe), {}
+    for k, v in servidores.items():
+        if k in (CLAVE, CLAVE_VIEJA):
+            nuevos.setdefault(CLAVE, entrada)
+        else:
+            nuevos[k] = v
+    nuevos.setdefault(CLAVE, entrada)
+    salida = dict(datos)
+    salida["mcpServers"] = nuevos
+    return salida
+
+
+def _descripcion(estado_actual: str, servidores) -> str:
+    if estado_actual == SIN_CONFIGURAR:
+        return f"add `{CLAVE}`"
+    if isinstance(servidores, dict) and CLAVE_VIEJA in servidores:
+        return f"replace `{CLAVE_VIEJA}` with `{CLAVE}`"
+    return f"update `{CLAVE}` (command, args [\"serve\"], no env)"
+
+
+def planificar(c: Cliente, exe: str) -> PlanCliente:
+    """What `aplicar` would do for this client. Never writes."""
+    if not c.encontrado:
+        return PlanCliente(c, NO_ENCONTRADO, ejecutable=exe)
+    try:
+        datos, texto = leer(c)
+        servidores = _servidores(c, datos)
+        if servidores is not None and not isinstance(servidores, dict):
+            raise ErrorInstalacion(f"{c.archivo}: the servers entry is not a table/object; nothing was changed.")
+        actual = estado_servidores(servidores, exe)
+        if actual == CONFIGURADO:
+            return PlanCliente(c, actual, ejecutable=exe)
+        plan = PlanCliente(c, actual, descripcion=_descripcion(actual, servidores), ejecutable=exe)
+        if c.formato == "toml":
+            plan.texto = clientes_toml.editar(texto, exe)
+        elif c.cli:
+            servidores = servidores or {}
+            plan.comandos = [["mcp", "remove", k, "--scope", "user"] for k in (CLAVE_VIEJA, CLAVE) if k in servidores]
+            plan.comandos.append(["mcp", "add", "--scope", "user", CLAVE, "--", exe, "serve"])
+            plan.descripcion += " via `claude mcp add --scope user`"
+        else:
+            plan.texto = texto_json(_reemplazar_json(c, datos, exe))
+        return plan
+    except ErrorInstalacion as e:
+        return PlanCliente(c, f"error: {e}", error=str(e), ejecutable=exe)
+    except OSError as e:
+        return PlanCliente(c, f"error: {e}", error=f"cannot read {c.archivo}: {e}", ejecutable=exe)
+
+
+def _validador(c: Cliente, exe: str) -> Callable[[str], None]:
+    def validar(texto: str) -> None:
+        if c.formato == "toml":
+            datos = clientes_toml.parsear(texto, f"the new {c.archivo.name}")
+        else:
+            try:
+                datos = json.loads(texto)
+            except ValueError as e:
+                raise ErrorInstalacion(f"the new {c.archivo.name} does not parse ({e}); nothing was changed.")
+        if estado_servidores(_servidores(c, datos), exe) != CONFIGURADO:
+            raise ErrorInstalacion(f"the new {c.archivo.name} does not have the expected `{CLAVE}` entry; "
+                                   "nothing was changed.")
+    return validar
+
+
+def aplicar(plan: PlanCliente, correr: Callable = subprocess.run) -> str:
+    """Executes the plan of one client; returns the summary line. ErrorInstalacion if it cannot."""
+    c = plan.cliente
+    if plan.error:
+        raise ErrorInstalacion(plan.error)
+    if not plan.cambia:
+        return f"{c.titulo}: {plan.estado}"
+    if plan.texto is not None:
+        bak = escribir_validado(c.archivo, plan.texto, _validador(c, plan.ejecutable))
+        return f"{c.titulo}: {plan.descripcion} in {c.archivo}" + (f" (backup: {bak})" if bak else "")
+    bak = respaldar(c.archivo)
+    for args in plan.comandos:
+        r = correr([c.cli, *args], capture_output=True, text=True)
+        if r.returncode != 0:
+            raise ErrorInstalacion(f"`claude {' '.join(args)}` failed: {(r.stderr or r.stdout).strip()[:300]}"
+                                   + (f" (backup of {c.archivo}: {bak})" if bak else ""))
+    final = estado(c, plan.ejecutable)
+    if final != CONFIGURADO:
+        raise ErrorInstalacion(f"after `claude mcp add`, {c.archivo} is in state '{final}'"
+                               + (f" (backup: {bak})" if bak else ""))
+    return f"{c.titulo}: {plan.descripcion}" + (f" (backup: {bak})" if bak else "")

ratifact/clientes_toml.py

@@ -0,0 +1,210 @@
+"""Bounded edit of ~/.codex/config.toml (T-013): only the `[mcp_servers.memoria-proyectos]` / `[mcp_servers.ratifact]`
+tables and their sub-tables are rewritten; every other line of the file stays byte for byte. The result is accepted only
+if parsing it gives exactly the original data with that one server replaced (tomllib, or tomli on Python 3.10); any
+other layout (inline tables, dotted keys, multi-line strings) is refused with manual instructions."""
+from __future__ import annotations
+
+import copy
+import json
+import re
+
+from ratifact.archivos import ErrorInstalacion
+from ratifact.vocabulario import HERRAMIENTAS_V0
+
+CLAVE, CLAVE_VIEJA = "ratifact", "memoria-proyectos"
+_QUITAR = ("command", "args", "env")
+_BARE = re.compile(r"[A-Za-z0-9_-]+")
+_PARTE = re.compile(r"""\s*(?:([A-Za-z0-9_-]+)|"((?:[^"\\]|\\.)*)"|'([^']*)')\s*""")
+_ASIGNACION = re.compile(r"""^\s*["']?(command|args|env)["']?\s*[=.]""")
+
+
+def _parser():
+    try:
+        import tomllib
+        return tomllib
+    except ModuleNotFoundError:
+        try:
+            import tomli
+            return tomli
+        except ModuleNotFoundError:
+            return None
+
+
+def parsear(texto: str, origen: str = "the file") -> dict:
+    toml = _parser()
+    if toml is None:
+        raise ErrorInstalacion("cannot validate TOML on this Python (install `tomli`, a dependency of ratifact on "
+                               "Python 3.10); nothing was changed.")
+    try:
+        return toml.loads(texto)
+    except toml.TOMLDecodeError as e:
+        raise ErrorInstalacion(f"{origen} is not valid TOML ({e}); fix it by hand, nothing was changed.") from None
+
+
+def manual(exe: str) -> str:
+    return (f"replace the `[mcp_servers.{CLAVE_VIEJA}]` server by hand with:\n"
+            f"        [mcp_servers.{CLAVE}]\n        command = {json.dumps(exe)}\n        args = [\"serve\"]\n"
+            f"      (delete its `.env` table; rename `[mcp_servers.{CLAVE_VIEJA}.tools.<tool>]` approval tables to "
+            f"`[mcp_servers.{CLAVE}.tools.<tool>]`)")
+
+
+def _clave(texto: str) -> list[str] | None:
+    """Dotted key of a table header (`a."b.c".d` → [a, b.c, d]); None if it cannot be read."""
+    partes, i = [], 0
+    while True:
+        m = _PARTE.match(texto, i)
+        if not m:
+            return None
+        bare, basica, literal = m.groups()
+        partes.append(bare if bare is not None else literal if literal is not None else json.loads(f'"{basica}"'))
+        i = m.end()
+        if i == len(texto):
+            return partes
+        if texto[i] != ".":
+            return None
+        i += 1
+
+
+def _cabecera(linea: str) -> tuple[list[str] | None, bool] | None:
+    """(key, is an array of tables) if the line is a table header; None otherwise."""
+    s = linea.strip()
+    if not s.startswith("["):
+        return None
+    doble = s.startswith("[[")
+    cuerpo, comillas, i = s[2:] if doble else s[1:], None, 0
+    while i < len(cuerpo):
+        ch = cuerpo[i]
+        if comillas:
+            if ch == "\\" and comillas == '"':
+                i += 1
+            elif ch == comillas:
+                comillas = None
+        elif ch in "\"'":
+            comillas = ch
+        elif ch == "]":
+            return _clave(cuerpo[:i]), doble
+        i += 1
+    return None, doble
+
+
+def _formatear(partes: list[str]) -> str:
+    return ".".join(p if _BARE.fullmatch(p) else json.dumps(p) for p in partes)
+
+
+def _secciones(lineas: list[str]) -> list[tuple[int, int, list[str] | None, bool]]:
+    """(start, end, key, array) of each table; the lines before the first header have key []."""
+    cabeceras = [(i, *c) for i, l in enumerate(lineas) if (c := _cabecera(l)) is not None]
+    inicios = [(0, [], False)] + cabeceras
+    fines = [i for i, *_ in cabeceras] + [len(lineas)]
+    return [(ini, fin, clave, doble) for (ini, clave, doble), fin in zip(inicios, fines)]
+
+
+def _profundidad(linea: str) -> int:
+    """Brackets opened minus closed outside strings and comments."""
+    n, comillas, i = 0, None, 0
+    while i < len(linea):
+        ch = linea[i]
+        if comillas:
+            if ch == "\\" and comillas == '"':
+                i += 1
+            elif ch == comillas:
+                comillas = None
+        elif ch in "\"'":
+            comillas = ch
+        elif ch == "#":
+            break
+        elif ch in "[{":
+            n += 1
+        elif ch in "]}":
+            n -= 1
+        i += 1
+    return n
+
+
+def _sin_asignaciones(cuerpo: list[str]) -> list[str]:
+    """The body of the main table without command/args/env (also multi-line arrays)."""
+    salida, i = [], 0
+    while i < len(cuerpo):
+        if _ASIGNACION.match(cuerpo[i]):
+            depth = _profundidad(cuerpo[i])
+            while depth > 0 and i + 1 < len(cuerpo):
+                i += 1
+                depth += _profundidad(cuerpo[i])
+        else:
+            salida.append(cuerpo[i])
+        i += 1
+    return salida
+
+
+def _herramienta(partes: list[str]) -> list[str]:
+    """`tools.obtener_contexto` (v0 Spanish name) → `tools.get_context`."""
+    if len(partes) >= 2 and partes[0] == "tools":
+        return ["tools", HERRAMIENTAS_V0.get(partes[1], partes[1]), *partes[2:]]
+    return partes
+
+
+def esperado(datos: dict, exe: str) -> dict:
+    """What the parsed file must be after the edit."""
+    d = copy.deepcopy(datos)
+    servidores = d.setdefault("mcp_servers", {})
+    viejo, actual = servidores.pop(CLAVE_VIEJA, None), servidores.pop(CLAVE, None)
+    fuente = actual if actual is not None else (viejo or {})
+    nuevo = {"command": exe, "args": ["serve"], **{k: v for k, v in fuente.items() if k not in _QUITAR}}
+    if isinstance(nuevo.get("tools"), dict):
+        herramientas: dict = {}
+        for k, v in nuevo["tools"].items():
+            herramientas.setdefault(HERRAMIENTAS_V0.get(k, k), v)
+        nuevo["tools"] = herramientas
+    servidores[CLAVE] = nuevo
+    return d
+
+
+def editar(texto: str, exe: str) -> str:
+    """New text of config.toml with the `ratifact` server (and without `memoria-proyectos`). ErrorInstalacion if the
+    layout is not the known one or the result would not be exactly the expected data."""
+    datos = parsear(texto)
+    lineas = texto.splitlines(keepends=True)
+    if lineas and not lineas[-1].endswith("\n"):
+        lineas[-1] += "\n"
+    secciones = _secciones(lineas)
+    nuestras = [s for s in secciones if s[2] and s[2][:1] == ["mcp_servers"] and s[2][1:2] in ([CLAVE], [CLAVE_VIEJA])]
+    if any(s[2] is None for s in secciones) or any(s[3] for s in nuestras):
+        raise ErrorInstalacion("config.toml has a table header this edit does not understand; " + manual(exe))
+    if any('"""' in l or "'''" in l for ini, fin, *_ in nuestras for l in lineas[ini:fin]):
+        raise ErrorInstalacion("config.toml uses multi-line strings in the server table; " + manual(exe))
+    clave_fuente = CLAVE if any(s[2][1] == CLAVE for s in nuestras) else CLAVE_VIEJA
+    principal = [f"[mcp_servers.{CLAVE}]\n", f"command = {json.dumps(exe)}\n", 'args = ["serve"]\n']
+    subtablas, vistas = [], set()
+    for ini, fin, clave, _ in nuestras:
+        if clave[1] != clave_fuente:
+            continue
+        if len(clave) == 2:
+            principal += _sin_asignaciones(lineas[ini + 1:fin])
+        elif clave[2] != "env":
+            nueva = ["mcp_servers", CLAVE, *_herramienta(clave[2:])]
+            if tuple(nueva) not in vistas:
+                vistas.add(tuple(nueva))
+                subtablas += [f"[{_formatear(nueva)}]\n", *lineas[ini + 1:fin]]
+    bloque = principal + subtablas
+    inicios = {s[0] for s in nuestras}
+    salida, puesto = [], False
+    for ini, fin, *_ in secciones:
+        if ini in inicios:
+            if not puesto:
+                salida += bloque
+                puesto = True
+            continue
+        salida += lineas[ini:fin]
+    if not puesto:
+        if salida and salida[-1].strip():
+            salida.append("\n")
+        salida += bloque
+    nuevo = "".join(salida)
+    try:
+        resultado = parsear(nuevo, "the edited config.toml")
+    except ErrorInstalacion:
+        resultado = None
+    if resultado != esperado(datos, exe):
+        raise ErrorInstalacion("the server is also defined outside its own table (inline table or dotted keys); "
+                               + manual(exe))
+    return nuevo