aioli-cli 0.1.28__tar.gz → 0.1.30__tar.gz

{aioli_cli-0.1.28 → aioli_cli-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aioli-cli
-Version: 0.1.28
+Version: 0.1.30
 Summary: aioli — local-first AI media suite CLI (images, video, music, voice, podcast)
 Author: aioli contributors
 License: MIT

{aioli_cli-0.1.28 → aioli_cli-0.1.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioli-cli"
-version = "0.1.28"
+version = "0.1.30"
 description = "aioli — local-first AI media suite CLI (images, video, music, voice, podcast)"
 readme = "README.md"
 requires-python = ">=3.12"

{aioli_cli-0.1.28 → aioli_cli-0.1.30}/src/aioli_cli/main.py

@@ -50,8 +50,14 @@ def _root(
 def doctor() -> None:
     """Preflight: python, ffmpeg, CUDA. Plugins append their own checks.
 
+    V3: además emite la lectura unificada por backend (misma que
+    `status` y `setup --check`): `plugin/backend → capacidad/probado`
+    es OK; el resto es fallo con el nivel como detalle.
     Exit 1 si algún check falla (usable en scripts/CI).
     """
+    from aioli_cli import _plugins as _plugmod  # noqa: PLC0415
+
+    _plugmod.load_all()
     cfg = AioliConfig.load()
     table = Table(title="aioli doctor")
     table.add_column("check")
@@ -71,6 +77,57 @@ def doctor() -> None:
                 check.hint,
             )
             ok = ok and check.ok
+    try:
+        from aioli_cli.readiness import doctor_checks_for, spec_for  # noqa: PLC0415
+        from aioli_contract import ModelFile, default_bin_dir, default_models_dir  # noqa: PLC0415
+        from aioli_contract.advise import read_machine  # noqa: PLC0415
+
+        _md, _bd = default_models_dir(), default_bin_dir()
+        _machine = read_machine(_md)
+        for plugin in registry.all():
+            if plugin.models is None:
+                continue
+            grouped: dict[str, list] = {}
+            for raw in plugin.models():
+                entry = ModelFile(**raw)
+                if entry.optional:
+                    continue
+                if entry.platform:
+                    import sys as _sys
+
+                    if entry.platform != _sys.platform:
+                        continue
+                if entry.kind == "runtime":
+                    continue
+                grouped.setdefault(entry.backend or "-", []).append(entry)
+            runtimes = []
+            for raw in plugin.models():
+                entry = ModelFile(**raw)
+                if entry.kind != "runtime" or entry.optional:
+                    continue
+                if entry.platform:
+                    import sys as _sys2
+
+                    if entry.platform != _sys2.platform:
+                        continue
+                runtimes.append(entry)
+            for backend, entries in sorted(grouped.items()):
+                if backend == "-":
+                    continue
+                try:
+                    spec = spec_for(plugin.name, backend)
+                except KeyError:
+                    continue
+                files = [e for e in runtimes if e.backend in ("", backend)] + entries
+                for check in doctor_checks_for(spec, files, _md, _bd, _machine):
+                    table.add_row(
+                        f"readiness/{check.name}",
+                        "✅" if check.ok else "❌",
+                        check.hint,
+                    )
+                    ok = ok and check.ok
+    except (ImportError, OSError, RuntimeError):
+        pass
     table.add_row("models_dir", "📁", str(cfg.models_dir))
     table.add_row("plugins", "🔌", ", ".join(registry.names()) or "(none yet)")
     console.print(table)
@@ -85,11 +142,14 @@ def setup(
         None, "--plugins", "-p", help="Solo estos plugins (coma): image,video,music,voice."
     ),
     ask: bool = typer.Option(False, "--ask", help="Pregunta qué instalar (por defecto: auto)."),
+    check: bool = typer.Option(
+        False, "--check", help="Solo muestra la lectura (misma que status) sin descargar."
+    ),
 ) -> None:
     """Asistente de primera instalación: equipo → consejo → descarga."""
     from aioli_cli.setup import run_setup
 
-    run_setup(yes=yes, plugins=plugins, ask=ask)
+    run_setup(yes=yes, plugins=plugins, ask=ask, check=check)
 
 
 @app.command()

aioli_cli-0.1.30/src/aioli_cli/readiness.py

@@ -0,0 +1,347 @@
+"""Evaluación readiness unificada V3 (D23): una sola lectura para status/doctor/setup.
+
+Consume ``BackendSpec``/``ExecutionPlan``/``Readiness`` de
+``aioli_contract.readiness`` sin duplicar detectores: las tres superficies
+llaman aquí con el MISMO input y obtienen la MISMA lectura.
+
+Mapa de detectores duplicados eliminados (V3.1):
+- ``status._piper_binary`` → :func:`motor_probe` (voice/piper).
+- ``setup._piper_ready`` → :func:`motor_probe` (voice/piper).
+- ``image.launcher.resolve_sd_cli`` + ``image.doctor`` (exists sin
+  bit-X) → :func:`motor_probe` (image/*, exige is_file + bit X).
+- ``music.paths.ace_server_binary`` + ``music.doctor`` (exists sin
+  probe unificado) → :func:`motor_probe` (music/*).
+- ``video.wgp.resolve_*`` + ``video.doctor`` (exists/which bool) →
+  :func:`motor_probe` (video/*, directorio nunca vale).
+- ``voice.cli.doctor._check_extras`` (which/find_spec bool) →
+  :func:`motor_probe` (voice/* SDK/binario, SDK faltante es desconocido).
+- ``contract.doctor`` baseline (python/ffmpeg/cuda) se mantiene como
+  preflight genérico; la lectura por backend vive aquí.
+
+Sin cambios de red/descarga: este módulo solo LEE (verify/quick/full,
+stat del bit X, resolve sin ejecutar salvo ``run_probe=True`` explícito).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from aioli_contract.doctor import Check
+from aioli_contract.readiness import (
+    BackendSpec,
+    ExecutionPlan,
+    ProbeOutcome,
+    Readiness,
+    check_exec_bit,
+    check_sdk,
+    probe_runtime,
+    rank,
+    resolve_backend,
+)
+
+__all__ = [
+    "BACKEND_SPECS",
+    "build_execution_plan",
+    "doctor_checks_for",
+    "evaluate_plugin",
+    "is_ready",
+    "motor_probe",
+    "spec_for",
+]
+
+BACKEND_SPECS: dict[tuple[str, str], BackendSpec] = {
+    ("image", "flux-klein"): BackendSpec(
+        plugin="image",
+        backend="flux-klein",
+        kind="binary",
+        binary_env="IMAGE_SD_CLI_BIN",
+        binary_names=("sd-cli",),
+    ),
+    ("image", "flux-klein-4b"): BackendSpec(
+        plugin="image",
+        backend="flux-klein-4b",
+        kind="binary",
+        binary_env="IMAGE_SD_CLI_BIN",
+        binary_names=("sd-cli",),
+    ),
+    ("music", "acestep"): BackendSpec(
+        plugin="music",
+        backend="acestep",
+        kind="binary",
+        binary_names=("ace-server",),
+    ),
+    ("music", "yue2"): BackendSpec(
+        plugin="music",
+        backend="yue2",
+        kind="binary",
+        binary_names=("audiocpp_cli",),
+    ),
+    ("video", "ltx25"): BackendSpec(
+        plugin="video",
+        backend="ltx25",
+        kind="binary",
+        binary_env="VIDEO_PYTHON",
+    ),
+    ("voice", "piper"): BackendSpec(
+        plugin="voice",
+        backend="piper",
+        kind="binary",
+        binary_env="PIPER_BIN",
+        binary_names=("piper",),
+    ),
+    ("voice", "kokoro"): BackendSpec(
+        plugin="voice",
+        backend="kokoro",
+        kind="sdk",
+        sdk_import="kokoro_onnx",
+        extra_name="voice-kokoro",
+    ),
+}
+
+
+def spec_for(plugin: str, backend: str) -> BackendSpec:
+    """Spec unificado por backend (estable V3: tabla cerrada, KeyError si falta)."""
+    try:
+        return BACKEND_SPECS[(plugin, backend)]
+    except KeyError:
+        raise KeyError(f"backend sin spec unificado: {plugin}/{backend}") from None
+
+
+def _managed_candidates(spec: BackendSpec, bin_dir: Path | None) -> list[Path]:
+    """Runtimes gestionados por `setup` en bin_dir (sin ejecutar nada)."""
+    if bin_dir is None:
+        return []
+    table: dict[tuple[str, str], list[str]] = {
+        ("image", "flux-klein"): ["sd-cli/sd-cli", "sd-cli"],
+        ("image", "flux-klein-4b"): ["sd-cli/sd-cli", "sd-cli"],
+        ("music", "acestep"): ["ace-server/ace-server", "ace-server"],
+        ("music", "yue2"): ["audiocpp/audiocpp_cli", "audiocpp_cli"],
+    }
+    return [bin_dir / rel for rel in table.get((spec.plugin, spec.backend), [])]
+
+
+def _legacy_candidates(spec: BackendSpec) -> list[Path]:
+    """Resolutores legacy de plugins (solo lectura, envueltos con bit-X).
+
+    Reutiliza los resolvers existentes sin duplicar su lógica de rutas;
+    la ESTRICTEZ (is_file + bit X, directorio nunca vale) la pone el
+    contrato vía :func:`check_exec_bit`.
+    """
+    out: list[Path] = []
+    try:
+        if spec.plugin == "image":
+            from aioli_image.launcher import resolve_sd_cli  # noqa: PLC0415
+
+            try:
+                out.append(resolve_sd_cli())
+            except (FileNotFoundError, OSError, RuntimeError, SystemExit):
+                pass
+        elif spec.plugin == "music" and spec.backend == "acestep":
+            from aioli_music.paths import ace_server_binary  # noqa: PLC0415
+
+            try:
+                out.append(ace_server_binary())
+            except (OSError, RuntimeError):
+                pass
+        elif spec.plugin == "music" and spec.backend == "yue2":
+            try:
+                from aioli_music.backends.yue2 import _cli as _yue2_cli  # noqa: PLC0415
+                from aioli_music.config import load_config  # noqa: PLC0415
+
+                try:
+                    out.append(_yue2_cli(load_config()))
+                except (OSError, RuntimeError, ValueError):
+                    pass
+            except (ImportError, OSError):
+                pass
+        elif spec.plugin == "video":
+            from aioli_video.wgp import resolve_python  # noqa: PLC0415
+
+            try:
+                out.append(resolve_python())
+            except (OSError, RuntimeError):
+                pass
+    except ImportError:
+        pass
+    return out
+
+
+def motor_probe(
+    spec: BackendSpec, bin_dir: Path | None, *, run_probe: bool = False, timeout: int = 10
+) -> ProbeOutcome:
+    """Motor presente+ejecutable con la MISMA vara en las tres superficies.
+
+    Orden: contrato (env+PATH) → gestionados (bin_dir) → legacy (plugins).
+    Cada candidato pasa por ``is_file`` + bit X (directorio, inventado y
+    sin-permiso son ``desconocido``, nunca éxito). SDK faltante es
+    ``desconocido``. Con ``run_probe=True`` se ejecuta ``--help`` con
+    timeout: colgado → ``desconocido`` (nunca éxito).
+    """
+    if spec.kind == "sdk":
+        return check_sdk(spec)
+    if spec.kind == "hybrid":
+        try:
+            resolved = resolve_backend(spec)
+            ok = check_exec_bit(resolved)
+            if ok.readiness == Readiness.MOTOR:
+                return _maybe_probe(resolved, ok, run_probe=run_probe, timeout=timeout)
+        except (FileNotFoundError, OSError, RuntimeError):
+            pass
+        return check_sdk(spec)
+    candidates: list[Path] = []
+    try:
+        candidates.append(resolve_backend(spec))
+    except (FileNotFoundError, OSError, RuntimeError):
+        pass
+    candidates.extend(_managed_candidates(spec, bin_dir))
+    candidates.extend(_legacy_candidates(spec))
+    for cand in candidates:
+        outcome = check_exec_bit(cand)
+        if outcome.readiness == Readiness.MOTOR:
+            return _maybe_probe(cand, outcome, run_probe=run_probe, timeout=timeout)
+    if spec.kind == "hybrid" or spec.sdk_import:
+        sdk = check_sdk(spec)
+        if sdk.readiness == Readiness.MOTOR:
+            return sdk
+    first = candidates[0] if candidates else None
+    if first is not None:
+        return ProbeOutcome(Readiness.DESCONOCIDO, f"{first} no ejecutable")
+    return ProbeOutcome(Readiness.DESCONOCIDO, f"motor {spec.plugin}/{spec.backend} no encontrado")
+
+
+def _maybe_probe(path: Path, ok: ProbeOutcome, *, run_probe: bool, timeout: int) -> ProbeOutcome:
+    if not run_probe:
+        return ok
+    probed = probe_runtime(path, timeout=timeout)
+    if probed.readiness == Readiness.MOTOR:
+        return ProbeOutcome(Readiness.MOTOR, f"{path} responde --help")
+    return ProbeOutcome(Readiness.DESCONOCIDO, probed.note)
+
+
+def evaluate_plugin(
+    spec: BackendSpec,
+    entries: list,
+    models_dir: Path,
+    bin_dir: Path | None,
+    *,
+    full: bool = False,
+    capacity_ok: bool | None = None,
+    tested: bool = False,
+    machine=None,
+    run_probe: bool = False,
+) -> Readiness:
+    """Escalera quick/full/probado con motor unificado (misma que el contrato).
+
+    Idéntica escalera que ``evaluate_readiness`` pero con :func:`motor_probe`
+    (contrato + gestionados + legacy con bit-X) en vez del solo-contrato:
+    mismo input → misma lectura en status, doctor y setup dry.
+    """
+    if not entries:
+        return Readiness.DESCONOCIDO
+    from aioli_contract.fetch import verify  # noqa: PLC0415
+
+    if machine is not None and capacity_ok is None:
+        try:
+            from aioli_contract.advise import judge  # noqa: PLC0415
+
+            capacity_ok = bool(judge(spec.plugin, spec.backend, machine).fits)
+        except Exception:  # noqa: BLE001
+            capacity_ok = None
+    for entry in entries:
+        if verify(entry, models_dir, bin_dir, quick=True) != "ok":
+            return Readiness.DESCONOCIDO
+    if not full:
+        level = Readiness.DESCARGADO
+        if motor_probe(spec, bin_dir, run_probe=run_probe).readiness == Readiness.MOTOR:
+            level = Readiness.MOTOR
+            if capacity_ok:
+                level = Readiness.CAPACIDAD
+        return level
+    for entry in entries:
+        if verify(entry, models_dir, bin_dir, quick=False) != "ok":
+            return Readiness.DESCARGADO
+    level = Readiness.INTEGRIDAD
+    if motor_probe(spec, bin_dir, run_probe=run_probe).readiness != Readiness.MOTOR:
+        return level
+    level = Readiness.MOTOR
+    if not capacity_ok:
+        return level
+    level = Readiness.CAPACIDAD
+    if tested:
+        return Readiness.PROBADO
+    return level
+
+
+def build_execution_plan(
+    spec: BackendSpec,
+    entries: list,
+    models_dir: Path,
+    bin_dir: Path | None,
+    *,
+    full: bool = True,
+    capacity_ok: bool | None = None,
+    tested: bool = False,
+    machine=None,
+) -> ExecutionPlan:
+    """Plan setup dry/check: ficheros, pasos, evidencia y faltantes (sin descargar)."""
+    from aioli_contract.fetch import verify  # noqa: PLC0415
+
+    evidence = evaluate_plugin(
+        spec,
+        entries,
+        models_dir,
+        bin_dir,
+        full=full,
+        capacity_ok=capacity_ok,
+        tested=tested,
+        machine=machine,
+    )
+    missing = tuple(e for e in entries if verify(e, models_dir, bin_dir) != "ok")
+    steps: list[str] = []
+    if missing:
+        steps.append(f"descargar {len(missing)} fichero(s) de {spec.plugin}/{spec.backend}")
+    if rank(evidence) < rank(Readiness.MOTOR):
+        steps.append(f"resolver motor {spec.plugin}/{spec.backend}")
+    if not steps:
+        steps.append("nada pendiente")
+    return ExecutionPlan(
+        spec=spec, files=tuple(entries), steps=tuple(steps), evidence=evidence, missing=missing
+    )
+
+
+def is_ready(level: Readiness) -> bool:
+    """Listo para generar: capacidad verificada (o probado)."""
+    return level in (Readiness.CAPACIDAD, Readiness.PROBADO)
+
+
+def doctor_checks_for(
+    spec: BackendSpec,
+    entries: list,
+    models_dir: Path,
+    bin_dir: Path | None,
+    machine=None,
+) -> list[Check]:
+    """Checks doctor por backend con la misma lectura que status/setup."""
+    from aioli_contract.advise import judge  # noqa: PLC0415
+
+    # V3 (F-4): None = capacidad sin medir (nunca se midió); no se
+    # confunde con el veredicto NEGATIVO medido del asesor, que es
+    # "no cabe". El hint no miente en ninguno de los tres casos.
+    fits: bool | None
+    if machine is None:
+        fits = None
+    else:
+        try:
+            fits = bool(judge(spec.plugin, spec.backend, machine).fits)
+        except Exception:  # noqa: BLE001
+            fits = False
+    level = evaluate_plugin(
+        spec, entries, models_dir, bin_dir, full=False, capacity_ok=bool(fits), machine=None
+    )
+    ok = is_ready(level)
+    detail = level.value
+    if fits is False:
+        detail += " (no cabe en este equipo)"
+    elif fits is None:
+        detail += " (capacidad sin medir)"
+    return [Check(name=f"{spec.plugin}/{spec.backend}", ok=ok, hint=detail)]

{aioli_cli-0.1.28 → aioli_cli-0.1.30}/src/aioli_cli/setup.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import sys
+from typing import TYPE_CHECKING
 
 import typer
 from rich.console import Console
@@ -12,6 +13,9 @@ from rich.table import Table
 
 console = Console()
 
+if TYPE_CHECKING:
+    from aioli_contract.readiness import Readiness  # noqa: F401 — anotación de _plan_readiness
+
 LEAGUE_LINES = {
     "patata": "🥔 Sin NVIDIA a la vista: tiraremos de CPU (voice) y poco más.",
     "modesta": "🛵 GPU modesta: motores ligeros y sin prisas.",
@@ -119,7 +123,9 @@ def select_plan(registry, machine) -> dict[str, list]:
     return plan
 
 
-def run_setup(yes: bool = False, plugins: str | None = None, ask: bool = False) -> None:
+def run_setup(
+    yes: bool = False, plugins: str | None = None, ask: bool = False, check: bool = False
+) -> None:
     from aioli_cli.fetch_ui import download_many, print_summary
     from aioli_contract import (
         check_space,
@@ -145,6 +151,22 @@ def run_setup(yes: bool = False, plugins: str | None = None, ask: bool = False)
     # quepa. Runtimes y ficheros de plataforma correcta incluidos.
     plan = select_plan(registry, machine)
 
+    if check:
+        # V3 --check: misma lectura que status --full, sin descargar ni preguntar.
+        from aioli_contract import default_bin_dir as _bdir  # noqa: PLC0415
+        from aioli_contract import default_models_dir as _mdir  # noqa: PLC0415
+
+        _md, _bd = _mdir(), _bdir()
+        for pn in sorted(plan):
+            missing, readiness = _plan_readiness(pn, plan[pn], _md, _bd, machine=machine)
+            state = (
+                "listo"
+                if not missing and readiness in ("capacidad", "probado")
+                else (readiness.value if readiness else "desconocido")
+            )
+            console.print(f"[dim]check {pn}: {state} ({len(missing)} pendiente(s))[/]")
+        return
+
     if plugins:
         requested = [p.strip() for p in plugins.split(",") if p.strip()]
         known = {p.name for p in registry.all() if p.models is not None}
@@ -383,15 +405,96 @@ def _persist_engine_defaults(chosen: dict[str, str]) -> None:
 
 
 def _piper_ready() -> bool:
+    """V3: mismo criterio que status/doctor (evaluación unificada)."""
+    try:
+        from aioli_cli.readiness import motor_probe, spec_for  # noqa: PLC0415
+        from aioli_contract import default_bin_dir  # noqa: PLC0415
+        from aioli_contract.readiness import Readiness  # noqa: PLC0415
+
+        spec = spec_for("voice", "piper")
+        return motor_probe(spec, default_bin_dir()).readiness == Readiness.MOTOR
+    except (KeyError, OSError, RuntimeError, ImportError):
+        pass
+    # V3 (F-6): el fallback tampoco gradua sin bit X - un binario
+    # presente pero no ejecutable es "pendiente", no exito.
     try:
+        from aioli_contract.readiness import (  # noqa: PLC0415
+            Readiness as _Readiness,
+        )
+        from aioli_contract.readiness import (
+            check_exec_bit,
+        )
         from aioli_voice.engines.piper import resolve_piper_bin  # noqa: PLC0415
 
-        resolve_piper_bin()
-        return True
-    except (OSError, RuntimeError):
+        return check_exec_bit(resolve_piper_bin()).readiness == _Readiness.MOTOR
+    except (OSError, RuntimeError, ImportError):
         return False
 
 
+def _plan_readiness(
+    pn: str, files: list, models_dir, bin_dir, *, machine=None
+) -> tuple[list, Readiness | None]:
+    """--check/dry_plan: pendientes + PEOR readiness de TODOS los backends (V3, F-2).
+
+    Antes solo se evaluaba el PRIMER backend del plan (un plan
+    multi-backend, p.ej. music acestep+yue2, quedaba subevaluado). Ahora
+    se agrupa por backend (como `aioli doctor`) y se agrega con la peor
+    lectura: un motor desconocido no es "listo" porque el otro gradue.
+    Backend sin spec unificada -> None (desconocido honesto, nunca exito).
+    """
+    from aioli_contract import verify as _verify  # noqa: PLC0415
+    from aioli_contract.readiness import rank as _rank
+
+    missing = [e for e in files if _verify(e, models_dir, bin_dir) != "ok"]
+    by_backend: dict[str, list] = {}
+    runtimes: list = []
+    for e in files:
+        if e.kind == "runtime":
+            runtimes.append(e)
+        elif e.backend:
+            by_backend.setdefault(e.backend, []).append(e)
+    if not by_backend:
+        return missing, None
+    levels: list[Readiness] = []
+    try:
+        from aioli_cli.readiness import build_execution_plan, spec_for  # noqa: PLC0415
+
+        for backend in sorted(by_backend):
+            spec = spec_for(pn, backend)
+            backend_files = [r for r in runtimes if r.backend in ("", backend)]
+            levels.append(
+                build_execution_plan(
+                    spec,
+                    backend_files + by_backend[backend],
+                    models_dir,
+                    bin_dir,
+                    machine=machine,
+                ).evidence
+            )
+    except (KeyError, ImportError, OSError, RuntimeError):
+        return missing, None
+    return missing, min(levels, key=_rank)
+
+
+def dry_plan(registry, machine) -> dict[str, object]:
+    """Plan setup sin descargar (V3.2 coherencia): misma lectura que status.
+
+    Devuelve por plugin ``{"files": [...], "missing": [...], "readiness": Readiness}``
+    con verificación full (como `setup` sin descargas pendientes). No escribe
+    nada ni pregunta: los tests comparan este dict con status/doctor.
+    """
+    from aioli_contract import default_bin_dir, default_models_dir  # noqa: PLC0415
+
+    models_dir = default_models_dir()
+    bin_dir = default_bin_dir()
+    plan = select_plan(registry, machine)
+    out: dict[str, object] = {}
+    for pn, files in plan.items():
+        missing, readiness = _plan_readiness(pn, files, models_dir, bin_dir, machine=machine)
+        out[pn] = {"files": files, "missing": missing, "readiness": readiness}
+    return out
+
+
 def _ensure_binaries(chosen: dict[str, str], yes: bool = False) -> list[str]:
     """Garantiza el motor ejecutable o devuelve la lista de pendientes.