tai-sql 0.7.10__tar.gz → 0.7.12__tar.gz

{tai_sql-0.7.10 → tai_sql-0.7.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.7.10
+Version: 0.7.12
 Summary: SQL database management and code generation tool
 License-Expression: MIT
 License-File: LICENSE

{tai_sql-0.7.10 → tai_sql-0.7.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-sql"
-version = "0.7.10"
+version = "0.7.12"
 description = "SQL database management and code generation tool"
 license = "MIT"
 license-files = ["LICENSE"]

{tai_sql-0.7.10 → tai_sql-0.7.12}/tai_sql/__init__.py

@@ -6,6 +6,7 @@ models using SQLAlchemy's declarative system.
 from __future__ import annotations
 from sqlalchemy.types import (
     BigInteger as bigint,
+    SmallInteger as smallint,
     Text as text,
     Numeric as numeric,
     LargeBinary as largebinary,
@@ -25,7 +26,7 @@ from .orm import (
     # DSL de cabecera del schema
     datasource, generate, query,
     # Core ORM components
-    Table, View, Enum, column, vector, vector_column, VectorColumn,
+    Table, View, Enum, column, vector, vector_column, VectorColumn, timestamptz,
     relation, unique_constraint, index_constraint,
     TriggerAPI, on_create, on_update, on_delete,
     trigger_api, col, onetomany, manytoone, onetoone, get_type_registry,
@@ -57,6 +58,8 @@ __all__ = [
     'date',
     'time',
     'bigint',
+    'smallint',
+    'timestamptz',
     'text',
     'numeric',
     'largebinary',

tai_sql-0.7.12/tai_sql/cli/commands/cmd_pull/funcs.py

@@ -0,0 +1,415 @@
+# -*- coding: utf-8 -*-
+"""
+La orquestación de `tai-sql pull`: conectar, leer, decidir, escribir.
+
+El comando de arriba solo traduce banderas y presenta; aquí está el flujo, que se puede
+ejecutar sin Click.
+
+**Es el único comando que invierte el patrón universal** (`00-filosofia.md`): no resuelve
+un schema para actuar sobre su mapeo, porque es el que fabrica el schema. La excepción está
+acotada a este módulo: en cuanto el fichero existe, `generate` y `push` vuelven al camino
+de siempre.
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator, Optional, Protocol, Sequence
+
+from sqlalchemy import Engine, event, inspect
+
+from tai_sql.connection import Provider
+from tai_sql.errors import ErrorCode, ProjectError, TaiSqlError
+from tai_sql.introspect import SchemaBlueprint, build, read_view_columns, render
+from tai_sql.introspect import list_schemas as _list_schemas
+from tai_sql.sync.state import build_remote_state
+
+
+@dataclass(frozen=True)
+class PullResult:
+    """
+    Lo que produjo un `pull`.
+
+    Attributes:
+        blueprint:  Lo que se dedujo, con sus descartes.
+        content:    El texto del fichero de schema.
+        schema_file: Dónde se escribió, o `None` con `--stdout`.
+        view_files: Los `.sql` escritos.
+        load_errors: Lo que falló al cargar el fichero antes de escribirlo. Solo puede
+            no estar vacío con `--stdout`: sin él, un fichero que no carga no se escribe.
+    """
+    blueprint: SchemaBlueprint
+    content: str
+    schema_file: Optional[Path] = None
+    view_files: tuple[Path, ...] = ()
+    load_errors: tuple[str, ...] = ()
+
+
+class PullProgress(Protocol):
+    """
+    Lo que `run_pull` cuenta mientras trabaja, para quien quiera enseñarlo.
+
+    Leer el catálogo de una base de datos grande —y más detrás de un túnel— tarda: un
+    `pull` de cien tablas puede pasar un minuto sin escribir nada, y eso no se distingue de
+    uno colgado. El flujo anuncia en qué fase está y cada consulta que lanza; pintarlo es
+    cosa de la capa de presentación.
+    """
+
+    def step(self, message: str) -> None:
+        """Empieza una fase: 'Leyendo tablas…'."""
+
+    def query(self) -> None:
+        """Se ha lanzado una consulta contra la base de datos."""
+
+
+class _Silent:
+    """El progreso que no se enseña: lo que recibe `run_pull` si nadie pide otro."""
+
+    def step(self, message: str) -> None:
+        pass
+
+    def query(self) -> None:
+        pass
+
+
+@contextmanager
+def _counting_queries(engine: Engine, progress: PullProgress) -> Iterator[None]:
+    """
+    Avisa al progreso de cada consulta que se lanza contra `engine` mientras dura.
+
+    Es la única señal de vida que da la reflexión: `MetaData.reflect` es una sola llamada
+    que no dice por qué tabla va. El `Engine` se cachea por provider, así que el listener
+    se retira al salir: no puede quedarse contando para el siguiente consumidor.
+    """
+    def _on_query(*_args, **_kwargs) -> None:
+        progress.query()
+
+    event.listen(engine, 'before_cursor_execute', _on_query)
+    try:
+        yield
+    finally:
+        event.remove(engine, 'before_cursor_execute', _on_query)
+
+
+def resolve_provider(source: str) -> Provider:
+    """
+    El proveedor de conexión, a partir de lo que se pasó en `-p/--provider`.
+
+    Las dos formas se distinguen por el `://`: sin él es el **nombre de una variable de
+    entorno**, que es el caso normal y el único que acaba escrito en el fichero.
+    """
+    if '://' in source:
+        return Provider.from_connection_string(source)
+    return Provider.from_environment(source)
+
+
+def resolve_db_schema(provider: Provider, requested: Optional[str]) -> str:
+    """
+    El schema de la base de datos que se va a leer.
+
+    Sin `--db-schema`, se usa el del motor (`public`, `dbo`) si existe, y si no el único
+    que haya. Con varios y ninguno por defecto, **se corta y se listan**: elegir uno por
+    orden alfabético sería adivinar, y leer el equivocado produce un schema completo y
+    equivocado, que es peor que un error.
+    """
+    driver = provider.driver
+    if driver is not None and not driver.supports_schemas():
+        # En MySQL el «schema» del datasource es la base de datos: es lo que declara
+        # cualquier schema de MySQL (`schema='mi_bd'`) y lo que el DDL usa de prefijo.
+        # Antes se devolvía `''`, que `datasource()` convierte en `'public'`: el push
+        # apuntaba a una base de datos `public` y `query()` buscaba las vistas en
+        # `views/public/`, así que el schema recién escrito ni siquiera cargaba.
+        return (
+            requested
+            or inspect(provider.engine).default_schema_name
+            or provider.database
+            or ''
+        )
+
+    if requested:
+        return requested
+
+    disponibles = _list_schemas(provider.engine)
+    por_defecto = inspect(provider.engine).default_schema_name
+
+    if por_defecto and por_defecto in disponibles:
+        return por_defecto
+
+    if len(disponibles) == 1:
+        return disponibles[0]
+
+    raise ProjectError(
+        message='La base de datos tiene varios schemas y ninguno es el del motor',
+        solution=(
+            f"Indica cuál leer con '--db-schema <nombre>'. Disponibles: "
+            f"{', '.join(disponibles) or '(ninguno)'}"
+        ),
+        code=ErrorCode.SCHEMA_NOT_FOUND,
+    )
+
+
+def run_pull(
+    *,
+    source: str = 'MAIN_DATABASE_URL',
+    db_schema: Optional[str] = None,
+    schema_name: Optional[str] = None,
+    env_var: Optional[str] = None,
+    syntax: str = 'v2',
+    exclude: Sequence[str] = (),
+    force: bool = False,
+    to_stdout: bool = False,
+    progress: Optional[PullProgress] = None,
+) -> PullResult:
+    """
+    Construye el fichero de schema que describe una base de datos.
+
+    Args:
+        source: Nombre de variable de entorno o cadena de conexión.
+        db_schema: Schema de la base de datos a leer.
+        schema_name: Nombre del fichero de schema. Por defecto, el del schema de la BD.
+        env_var: Variable que se escribirá en `env(...)`. Por defecto, la de `source`
+            cuando se pasó una variable; `MAIN_DATABASE_URL` cuando se pasó una cadena.
+        syntax: 'v1' o 'v2'.
+        exclude: Tablas que no se declaran.
+        force: Sobrescribir un fichero de schema existente.
+        to_stdout: No escribir nada; devolver el contenido.
+        progress: A quién contarle en qué fase va. Ver `PullProgress`.
+
+    Returns:
+        El resultado, con el blueprint para poder informar de los descartes.
+    """
+    from tai_sql import pm
+
+    if pm.find_project_root() is None:
+        raise ProjectError(
+            message='No estás dentro de un proyecto tai-sql',
+            solution=(
+                "pull escribe en 'schemas/' y en 'views/', así que necesita un proyecto. "
+                "Ejecútalo desde el directorio del proyecto o crea uno con "
+                "'tai-sql init <nombre>'."
+            ),
+            code=ErrorCode.PROJECT_NOT_FOUND,
+        )
+
+    provider = resolve_provider(source)
+    driver = provider.driver
+
+    if driver is None:
+        raise TaiSqlError(
+            message=f"No hay driver para '{provider.drivername}'",
+            solution=(
+                'Los motores soportados son postgresql, mysql, mssql y bigquery. '
+                'Comprueba el prefijo de la URL de conexión.'
+            ),
+            code=ErrorCode.INVALID_PROVIDER,
+        )
+
+    progress = progress or _Silent()
+
+    with _counting_queries(provider.engine, progress):
+        return _pull(
+            pm, provider, driver, progress,
+            source=source, db_schema=db_schema, schema_name=schema_name,
+            env_var=env_var, syntax=syntax, exclude=exclude, force=force,
+            to_stdout=to_stdout,
+        )
+
+
+def _pull(
+    pm, provider: Provider, driver, progress: PullProgress, *,
+    source: str, db_schema: Optional[str], schema_name: Optional[str],
+    env_var: Optional[str], syntax: str, exclude: Sequence[str], force: bool,
+    to_stdout: bool,
+) -> PullResult:
+    """El flujo de `run_pull`, una vez resuelto el origen."""
+    progress.step(f'Conectando con {provider.database or provider.drivername}')
+    destino_db = resolve_db_schema(provider, db_schema)
+    nombre = schema_name or destino_db or 'main'
+
+    fichero = pm.paths.schema_file(nombre)
+    if fichero.exists() and not (force or to_stdout):
+        raise ProjectError(
+            message=f"El schema '{nombre}' ya existe en este proyecto",
+            solution=(
+                "pull no sobrescribe: un schema puede tener docstrings, feed(), triggers "
+                "y columnas calculadas que la base de datos no contiene y que pull no "
+                f"sabe reconstruir. Usa '--force' para sobrescribirlo de todas formas, "
+                f"'-s <otro nombre>' para escribir uno nuevo, o '--stdout' para verlo sin "
+                f"tocar el disco."
+            ),
+            location=str(fichero),
+            code=ErrorCode.DUPLICATE_NAME,
+        )
+
+    progress.step(f"Leyendo el catálogo de '{destino_db}'")
+    estado, _ = build_remote_state(
+        provider.engine, driver, destino_db or None, target=nombre
+    )
+
+    if estado.views:
+        progress.step(f'Leyendo {len(estado.views)} vista(s)')
+    columnas_vista = read_view_columns(
+        provider.engine, driver, destino_db or None, list(estado.views)
+    )
+
+    progress.step(f'Deduciendo el schema ({len(estado.tables)} tablas)')
+    blueprint = build(
+        estado,
+        driver,
+        name=nombre,
+        db_schema=destino_db,
+        env_var=env_var or _env_var_for(source),
+        syntax=syntax,
+        view_columns=columnas_vista,
+        exclude=exclude,
+    )
+
+    contenido = render(blueprint)
+
+    progress.step('Comprobando que el schema carga')
+    errores = self_check(blueprint, provider)
+
+    if to_stdout:
+        return PullResult(blueprint=blueprint, content=contenido, load_errors=errores)
+
+    if errores:
+        detalle = '\n'.join(f'   · {e}' for e in errores)
+        raise TaiSqlError(
+            message=(
+                f"El schema que ha deducido pull no carga, así que no se ha escrito:\n"
+                f"{detalle}"
+            ),
+            solution=(
+                "Es un fallo de tai-sql pull, no de tu base de datos: repórtalo con este "
+                "mensaje. Mientras tanto, 'tai-sql pull --stdout' imprime el fichero para "
+                "que lo completes a mano."
+            ),
+            code=ErrorCode.SCHEMA_IMPORT_FAILED,
+        )
+
+    progress.step('Escribiendo el schema')
+    escritas = _write(pm, blueprint, contenido, fichero)
+
+    return PullResult(
+        blueprint=blueprint,
+        content=contenido,
+        schema_file=fichero,
+        view_files=escritas,
+    )
+
+
+def self_check(blueprint: SchemaBlueprint, provider: Provider) -> tuple[str, ...]:
+    """
+    Carga y analiza el schema deducido, en un proyecto temporal, antes de escribirlo.
+
+    `pull` tiene que escribir un schema **que cargue**, y hasta ahora nada lo comprobaba.
+    La primera base de datos ajena sobre la que se ejecutó dio un fichero que no se podía
+    ni importar —las vistas estaban donde `query()` no las buscaba, y tres tablas tenían
+    dos claves foráneas hacia la misma tabla, que el análisis rechazaba—, y el desarrollador
+    se enteraba al ejecutar el comando siguiente.
+
+    Es el mismo camino que seguirá `generate`: el import del fichero con sus `query()` y
+    el análisis completo. Se hace en un directorio temporal, con los generadores apuntando
+    dentro de él —instanciar uno crea su directorio—, y restaurando el schema y el
+    registro activos: comprobar no deja rastro.
+
+    Returns:
+        Los errores, uno por línea; vacío si el schema carga.
+    """
+    from tai_sql.errors import TaiSqlError as _Error
+    from tai_sql.orm.analysis import ErrorCollector
+    from tai_sql.orm.registry import use_registry
+    from tai_sql.project.context import use_schema
+    from tai_sql.schema import SchemaManager
+
+    with tempfile.TemporaryDirectory(prefix='tai-sql-pull-') as tmp:
+        raiz = Path(tmp)
+        contenido = render(
+            blueprint,
+            client_dir=str(raiz / 'cliente'),
+            diagrams_dir=str(raiz / 'diagramas'),
+        )
+        fichero = raiz / 'schemas' / f'{blueprint.name}.py'
+        fichero.parent.mkdir(parents=True)
+        fichero.write_text(contenido, encoding='utf-8')
+        _write_views(raiz / 'views', blueprint)
+
+        # El `env(...)` del fichero se resuelve al importarlo. Si la variable no está
+        # definida —se pasó una cadena de conexión con `-p`—, se le da la del origen
+        # solo mientras dura la comprobación.
+        faltaba = blueprint.env_var not in os.environ
+        if faltaba:
+            os.environ[blueprint.env_var] = provider.url.render_as_string(
+                hide_password=False
+            )
+
+        try:
+            with use_registry(), use_schema(None):
+                manager = SchemaManager(blueprint.name, fichero)
+                with use_schema(manager):
+                    manager.load()
+                    manager.validations()
+                    collector = ErrorCollector(
+                        context=f"Schema '{blueprint.name}'", enable_colors=False
+                    )
+                    manager.analyze(collector)
+                    return tuple(e.message for e in collector.get_errors())
+        except _Error as exc:
+            return (exc.message,)
+        except Exception as exc:  # el import de un fichero puede lanzar cualquier cosa
+            return (f'{type(exc).__name__}: {exc}',)
+        finally:
+            if faltaba:
+                os.environ.pop(blueprint.env_var, None)
+
+
+def _views_dir(views_root: Path, blueprint: SchemaBlueprint) -> Path:
+    """
+    El directorio de las vistas: el mismo que resolverá `query()`.
+
+    `query()` busca en `views/<schema del datasource>/`, y el schema del datasource es el
+    que `pull` escribe (`blueprint.db_schema`). Con `''` el datasource cae en `'public'`,
+    y por eso también aquí.
+    """
+    return views_root / (blueprint.db_schema or 'public')
+
+
+def _write_views(views_root: Path, blueprint: SchemaBlueprint) -> tuple[Path, ...]:
+    """Escribe el `.sql` de cada vista donde `query()` lo va a buscar."""
+    if not blueprint.views:
+        return ()
+
+    destino = _views_dir(views_root, blueprint)
+    destino.mkdir(parents=True, exist_ok=True)
+
+    escritas = []
+    for vista in blueprint.views:
+        ruta = destino / vista.sql_file
+        ruta.write_text(vista.sql + '\n', encoding='utf-8')
+        escritas.append(ruta)
+
+    return tuple(escritas)
+
+
+def _env_var_for(source: str) -> str:
+    """
+    La variable de entorno que se escribirá en el fichero.
+
+    Nunca la cadena de conexión, aunque sea lo que se pasó: el schema se commitea, y una
+    contraseña dentro de él no se retira del historial. Con una cadena literal se usa el
+    nombre convencional, que el desarrollador cambia con `--env-var` si el suyo es otro.
+    """
+    return 'MAIN_DATABASE_URL' if '://' in source else source
+
+
+def _write(pm, blueprint: SchemaBlueprint, contenido: str, fichero: Path) -> tuple[Path, ...]:
+    """Escribe el schema y los `.sql` de sus vistas."""
+    fichero.parent.mkdir(parents=True, exist_ok=True)
+    fichero.write_text(contenido, encoding='utf-8')
+    return _write_views(pm.paths.views_dir, blueprint)
+
+
+__all__ = ['PullProgress', 'PullResult', 'run_pull', 'resolve_provider', 'resolve_db_schema', 'self_check']

{tai_sql-0.7.10 → tai_sql-0.7.12}/tai_sql/cli/commands/cmd_pull/main.py

@@ -16,6 +16,8 @@ Este módulo es la capa de presentación; el flujo está en `funcs.py`.
 from __future__ import annotations
 
 import sys
+from contextlib import contextmanager
+from typing import Iterator, Optional
 
 import click
 
@@ -61,22 +63,31 @@ from .funcs import run_pull
 def pull(provider, db_schema, schema_name, env_var, syntax, exclude, to_stdout, force):
     """Construye el schema a partir de una base de datos existente"""
 
-    resultado = run_pull(
-        source=provider,
-        db_schema=db_schema,
-        schema_name=schema_name,
-        env_var=env_var,
-        syntax=syntax,
-        exclude=exclude,
-        force=force,
-        to_stdout=to_stdout,
-    )
+    with _progress() as progreso:
+        resultado = run_pull(
+            source=provider,
+            db_schema=db_schema,
+            schema_name=schema_name,
+            env_var=env_var,
+            syntax=syntax,
+            exclude=exclude,
+            force=force,
+            to_stdout=to_stdout,
+            progress=progreso,
+        )
 
     if to_stdout:
         # El schema por stdout y el informe por stderr: así se puede canalizar el fichero
         # a un `diff` sin que los avisos lo ensucien.
         click.echo(resultado.content, nl=False)
         _report(resultado.blueprint, stream=sys.stderr)
+        if resultado.load_errors:
+            render_warning(
+                "Este schema NO carga tal cual, y sin --stdout no se habría escrito:\n"
+                + '\n'.join(f"   · {e}" for e in resultado.load_errors),
+                hint="Es un fallo de tai-sql pull: repórtalo con este mensaje.",
+                stream=sys.stderr,
+            )
         return
 
     click.echo(f"✅ Schema escrito en {resultado.schema_file}")
@@ -92,6 +103,60 @@ def pull(provider, db_schema, schema_name, env_var, syntax, exclude, to_stdout,
     )
 
 
+class _Spinner:
+    """
+    El progreso de `pull` en una línea que se reescribe: fase, consultas y tiempo.
+
+    El contador de consultas es la señal de vida. La reflexión es una sola llamada que no
+    dice por qué tabla va; que el número suba es lo que distingue un `pull` que trabaja de
+    uno colgado. Va por stderr, igual que el informe, para no mezclarse con `--stdout`.
+    """
+
+    def __init__(self, progress) -> None:
+        self._progress = progress
+        self._task = progress.add_task('Preparando…', total=None, queries=0)
+        self._queries = 0
+
+    def step(self, message: str) -> None:
+        self._progress.update(self._task, description=f'{message}…')
+
+    def query(self) -> None:
+        self._queries += 1
+        self._progress.update(self._task, queries=self._queries)
+
+
+@contextmanager
+def _progress() -> Iterator[Optional[_Spinner]]:
+    """
+    El spinner, solo si stderr es un terminal.
+
+    En un script o en CI no hay nadie mirando, y una línea que se reescribe acaba en el log
+    como basura. Sin terminal, `run_pull` recibe `None` y no cuenta nada. `transient` borra
+    la línea al terminar: lo que queda en pantalla es el resultado, no el andamiaje.
+
+    Se pregunta a `isatty()` y no a `Console.is_terminal`, que con `FORCE_COLOR` dice que sí
+    a cualquier salida: poder pintar colores no significa que haya alguien mirando.
+    """
+    if not sys.stderr.isatty():
+        yield None
+        return
+
+    from rich.console import Console
+    from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+
+    consola = Console(file=sys.stderr)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn('{task.description}'),
+        TextColumn('[dim]{task.fields[queries]} consultas[/dim]'),
+        TimeElapsedColumn(),
+        console=consola,
+        transient=True,
+    ) as progress:
+        yield _Spinner(progress)
+
+
 def _resumen(blueprint: SchemaBlueprint) -> None:
     """Qué se ha reconstruido, en una línea por tipo de objeto."""
     click.echo(

{tai_sql-0.7.10 → tai_sql-0.7.12}/tai_sql/cli/commands/cmd_rules/main.py

@@ -19,7 +19,14 @@ from typing import Optional, Sequence
 
 import click
 
-from tai_sql.rules import RuleState, current_version, installer_for, schema_context
+from tai_sql.rules import (
+    RuleState,
+    current_version,
+    installer_for,
+    legacy_rules_dir,
+    retire_directory,
+    schema_context,
+)
 
 from ...preamble import available_schemas, load_schema, resolve_schema_name
 
@@ -53,7 +60,9 @@ def _contexts(names: Sequence[str]) -> list:
     contextos = []
     for nombre in names:
         manager = load_schema(nombre)
-        contextos.append(schema_context(nombre, manager, pm.paths.root))
+        contextos.append(
+            schema_context(nombre, manager, pm.paths.root, pm.paths.workspace_root)
+        )
     return contextos
 
 
@@ -67,6 +76,44 @@ def _target_dir():
     return pm.paths.platform_rules_dir
 
 
+def _retire_legacy() -> None:
+    """
+    Retira las reglas de la ubicación de antes de la 0.7.12, dentro del proyecto.
+
+    Allí el asistente solo las cargaba al leer un fichero de esa carpeta, y dejarlas
+    tendría dos copias de versiones distintas diciendo cosas distintas.
+    """
+    from tai_sql import pm
+
+    antigua = legacy_rules_dir(pm.paths)
+    if antigua is None:
+        return
+    retirada = retire_directory(antigua, stop=pm.paths.root)
+    for nombre in retirada.removed:
+        click.echo(f"   🗑️  {nombre} (de la ubicación antigua)")
+    if retirada.kept:
+        click.echo()
+        click.echo(
+            f"⚠️  En {antigua} quedan {', '.join(retirada.kept)}, que alguien editó: no se "
+            f"han borrado. Las reglas están ahora en {pm.paths.platform_rules_dir}; "
+            f"borra esa carpeta cuando hayas recuperado lo que necesites."
+        )
+    click.echo()
+
+
+def _legacy_reason() -> str:
+    """Por qué la ubicación antigua desalinea, o cadena vacía si no hay nada allí."""
+    from tai_sql import pm
+
+    antigua = legacy_rules_dir(pm.paths)
+    if antigua is None:
+        return ''
+    return (
+        f"hay reglas en {antigua}, la ubicación de antes de la 0.7.12, que el asistente "
+        f"no carga al arrancar"
+    )
+
+
 @click.group()
 def rules():
     """Gestiona las reglas de contexto para asistentes de IA"""
@@ -96,6 +143,7 @@ def rules_install(schema: Optional[str], force: bool):
     parcial = bool(schema)
     instalador = installer_for(destino, _contexts(nombres), track_orphans=not parcial)
     resultado = instalador.install(force=force)
+    _retire_legacy()
 
     for nombre in resultado.written:
         click.echo(f"   ✅ {nombre}")
@@ -159,11 +207,13 @@ def rules_check(schema: Optional[str]):
         destino, _contexts(nombres), track_orphans=not parcial
     ).inspect()
 
-    if informe.aligned:
+    antigua = _legacy_reason()
+    if informe.aligned and not antigua:
         click.echo(f"✅ Las reglas están al día (tai-sql {informe.version})")
         return
 
-    click.echo(f"❌ Las reglas no están al día: {informe.reason()}")
+    motivo = '; '.join(m for m in (informe.reason(), antigua) if m)
+    click.echo(f"❌ Las reglas no están al día: {motivo}")
     click.echo()
 
     if informe.installed and informe.installed_version:
@@ -208,6 +258,11 @@ def rules_diff(schema: Optional[str]):
         destino, _contexts(nombres), track_orphans=not parcial
     ).inspect()
 
+    antigua = _legacy_reason()
+    if antigua:
+        click.echo(f"ℹ️  Además, {antigua}: 'tai-sql rules install' las retira.")
+        click.echo()
+
     if informe.aligned:
         click.echo(f"✅ No hay diferencias (tai-sql {informe.version})")
         return