aioli-cli 0.1.0__py3-none-any.whl

aioli_cli/_plugins.py

@@ -0,0 +1,118 @@
+"""Lazy plugin loader: import each installed plugin package and register it.
+
+Plugins are optional — a missing package is silently skipped so the `aioli`
+binary keeps working with whatever is installed.
+"""
+
+from aioli_cli.registry import Plugin, registry
+
+
+_LOADED = False
+
+
+def load_all() -> None:
+    """Import plugin packages and register their Typer apps + checks."""
+    global _LOADED
+    if _LOADED:
+        return
+    _LOADED = True
+    try:
+        from aioli_voice.models_data import DEFAULT_BACKEND as VOICE_DEFAULT
+        from aioli_voice.models_data import MODELS as VOICE_MODELS
+        from aioli_voice.plugin import DESCRIPTION, voice_app, voice_checks
+
+        registry.register(
+            Plugin(
+                name="voice",
+                description=DESCRIPTION,
+                app=voice_app,
+                checks=voice_checks,
+                models=lambda: VOICE_MODELS,
+                default_backend=VOICE_DEFAULT,
+            )
+        )
+    except ImportError:
+        pass
+    try:
+        from aioli_image.models_data import GATED_NOTE as IMAGE_GATED
+        from aioli_image.models_data import DEFAULT_BACKEND as IMAGE_DEFAULT
+        from aioli_image.models_data import MODELS as IMAGE_MODELS
+        from aioli_image.plugin import DESCRIPTION, image_app, image_checks
+
+        registry.register(
+            Plugin(
+                name="image",
+                description=DESCRIPTION,
+                app=image_app,
+                checks=image_checks,
+                models=lambda: IMAGE_MODELS,
+                default_backend=IMAGE_DEFAULT,
+                gated_note=IMAGE_GATED,
+            )
+        )
+    except ImportError:
+        pass
+    try:
+        from aioli_video.models_data import GATED_NOTE as VIDEO_GATED
+        from aioli_video.models_data import DEFAULT_BACKEND as VIDEO_DEFAULT
+        from aioli_video.models_data import MODELS as VIDEO_MODELS
+        from aioli_video.plugin import DESCRIPTION, video_app, video_checks
+
+        registry.register(
+            Plugin(
+                name="video",
+                description=DESCRIPTION,
+                app=video_app,
+                checks=video_checks,
+                models=lambda: VIDEO_MODELS,
+                default_backend=VIDEO_DEFAULT,
+                gated_note=VIDEO_GATED,
+            )
+        )
+    except ImportError:
+        pass
+    try:
+        from aioli_podcast.plugin import DESCRIPTION, podcast_app, podcast_checks
+
+        registry.register(
+            Plugin(
+                name="podcast",
+                description=DESCRIPTION,
+                app=podcast_app,
+                checks=podcast_checks,
+            )
+        )
+    except ImportError:
+        pass
+    try:
+        from aioli_master.plugin import DESCRIPTION, master_app, master_checks
+
+        registry.register(
+            Plugin(
+                name="master",
+                description=DESCRIPTION,
+                app=master_app,
+                checks=master_checks,
+            )
+        )
+    except ImportError:
+        pass
+    try:
+        from aioli_music.models_data import GATED_NOTE as MUSIC_GATED
+        from aioli_music.models_data import DEFAULT_BACKEND as MUSIC_DEFAULT
+        from aioli_music.models_data import MODELS as MUSIC_MODELS
+        from aioli_music.plugin import DESCRIPTION, music_app, music_checks
+
+        registry.register(
+            Plugin(
+                name="music",
+                description=DESCRIPTION,
+                app=music_app,
+                checks=music_checks,
+                models=lambda: MUSIC_MODELS,
+                default_backend=MUSIC_DEFAULT,
+                gated_note=MUSIC_GATED,
+            )
+        )
+    except ImportError:
+        pass

aioli_cli/main.py

@@ -0,0 +1,215 @@
+"""aioli CLI entry point."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from aioli_cli.registry import registry
+from aioli_contract import AioliConfig, run_checks
+
+app = typer.Typer(
+    name="aioli",
+    help="🧄 aioli — local-first AI media suite.",
+    rich_markup_mode="rich",
+)
+console = Console()
+
+
+@app.command()
+def doctor() -> None:
+    """Preflight: python, ffmpeg, CUDA. Plugins append their own checks."""
+    cfg = AioliConfig.load()
+    table = Table(title="aioli doctor")
+    table.add_column("check")
+    table.add_column("status")
+    table.add_column("detail")
+    for check in run_checks():
+        table.add_row(check.name, "✅" if check.ok else "❌", check.hint)
+    for plugin in registry.all():
+        if plugin.checks is None:
+            continue
+        for check in plugin.checks():
+            table.add_row(
+                f"{plugin.name}/{check.name}",
+                "✅" if check.ok else "❌",
+                check.hint,
+            )
+    table.add_row("models_dir", "📁", str(cfg.models_dir))
+    table.add_row("plugins", "🔌", ", ".join(registry.names()) or "(none yet)")
+    console.print(table)
+
+
+@app.command()
+def setup(
+    yes: bool = typer.Option(False, "--yes", "-y", help="Sin preguntas: instala todo lo que quepa."),
+    plugins: str | None = typer.Option(None, "--plugins", "-p", help="Solo estos plugins (coma): image,video,music,voice."),
+) -> None:
+    """Asistente de primera instalación: equipo → consejo → descarga."""
+    from aioli_cli.setup import run_setup
+
+    run_setup(yes=yes, plugins=plugins)
+
+
+@app.command()
+def version() -> None:
+    """Show version."""
+    console.print("aioli 0.1.0")
+
+
+models_app = typer.Typer(help="Download + verify weight files.")
+app.add_typer(models_app, name="models")
+
+
+def _wanted(plugin: str | None, backend: str | None = None) -> list[tuple[str, dict]]:
+    from aioli_cli import _plugins  # noqa: PLC0415 — ensure loaded
+
+    _plugins.load_all()
+    out: list[tuple[str, dict]] = []
+    for p in registry.all():
+        if p.models is None:
+            continue
+        if plugin is not None and p.name != plugin:
+            continue
+        want = backend or p.default_backend or None
+        for entry in p.models():
+            if want is not None and want != "all" and entry.get("backend", "") != want:
+                continue
+            out.append((p.name, entry))
+    if plugin is not None and not out:
+        raise typer.BadParameter(f"no model manifest for plugin '{plugin}'")
+    return out
+
+
+def _backends() -> dict[str, list[str]]:
+    from aioli_cli import _plugins  # noqa: PLC0415 — ensure loaded
+
+    _plugins.load_all()
+    out: dict[str, list[str]] = {}
+    for p in registry.all():
+        if p.models is None:
+            continue
+        seen = sorted({e.get("backend", "?") for e in p.models()})
+        out[p.name] = seen
+    return out
+
+
+@models_app.command("list")
+def models_list(
+    plugin: str | None = typer.Argument(None),
+    backend: str | None = typer.Option(None, "--backend", "-b", help="Engine filter (default: plugin default; 'all' = every engine)."),
+) -> None:
+    """Show manifest entries + local status."""
+    from aioli_contract import ModelFile, default_models_dir, human_gb, verify
+
+    models_dir = default_models_dir()
+    table = Table(title=f"aioli models → {models_dir}")
+    table.add_column("plugin")
+    table.add_column("engine")
+    table.add_column("file")
+    table.add_column("size")
+    table.add_column("status")
+    for pname, raw in _wanted(plugin, backend):
+        entry = ModelFile(**raw)
+        status = verify(entry, models_dir)
+        icon = {"ok": "✅", "missing": "⬇️", "corrupt": "⚠️", "unverified": "❔"}[status]
+        table.add_row(pname, entry.backend or "-", entry.rel, human_gb(entry.size), f"{icon} {status}")
+    console.print(table)
+    if plugin is None and backend in (None, "all"):
+        for pname, engines in _backends().items():
+            console.print(f"   {pname} engines: {', '.join(engines)}")
+
+
+@models_app.command("download")
+def models_download(
+    plugin: str | None = typer.Argument(None),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+    backend: str | None = typer.Option(None, "--backend", "-b", help="Engine only (default: plugin default; 'all' = every engine)."),
+    with_optional: bool = typer.Option(False, "--with-optional", help="Include optional files (ASR, alt quants)."),
+) -> None:
+    """Download weights with resume + sha256 verification."""
+    from aioli_contract import (
+        ModelFile,
+        check_space,
+        default_models_dir,
+        download,
+        human_gb,
+        verify,
+    )
+    from rich.progress import Progress
+
+    models_dir = default_models_dir()
+    wanted = [(pn, ModelFile(**raw)) for pn, raw in _wanted(plugin, backend)]
+    if not with_optional:
+        skipped = [e.rel for _, e in wanted if e.optional]
+        wanted = [(pn, e) for pn, e in wanted if not e.optional]
+        for rel in skipped:
+            console.print(f"⏭️  optional skipped: {rel} (use --with-optional)")
+    missing = [(pn, e) for pn, e in wanted if verify(e, models_dir) != "ok"]
+    if not missing:
+        console.print("✅ all models present + verified")
+        return
+    total = sum(e.size for _, e in missing)
+    fits, _needed, free = check_space([e for _, e in missing], models_dir)
+    console.print(f"⬇️  {len(missing)} file(s), {human_gb(total)} → {models_dir}")
+    if free:
+        console.print(f"   disk free: {human_gb(free)}")
+    if not fits:
+        raise typer.Abort(f"❌ not enough disk space for {human_gb(total)}")
+    notes = {registry._plugins[pn].gated_note for pn, _ in missing}
+    for note in sorted(n for n in notes if n):
+        console.print(f"🔑 {note}")
+    if not yes and not typer.confirm("Download now?"):
+        raise typer.Abort()
+
+    class _Bar:
+        def __init__(self, progress: Progress) -> None:
+            self.progress = progress
+            self.tasks: dict[str, int] = {}
+
+        def update(self, path, done_bytes: int, total_bytes: int) -> None:
+            key = str(path)
+            task = self.tasks.get(key)
+            if task is None:
+                task = self.progress.add_task(path.name, total=total_bytes or 1)
+                self.tasks[key] = task
+            self.progress.update(task, completed=done_bytes, total=total_bytes or 1)
+
+    with Progress() as progress:
+        bar = _Bar(progress)
+        for _pn, entry in missing:
+            try:
+                download(entry, models_dir, progress=bar)
+            except (IOError, ValueError) as exc:
+                console.print(f"❌ {entry.rel}: {exc}")
+                raise typer.Abort() from exc
+    console.print("✅ all models present + verified")
+
+
+@models_app.command("verify")
+def models_verify(plugin: str | None = typer.Argument(None)) -> None:
+    """Re-hash local files against the manifest."""
+    from aioli_contract import ModelFile, default_models_dir, verify
+
+    models_dir = default_models_dir()
+    bad = 0
+    for pname, raw in _wanted(plugin):
+        entry = ModelFile(**raw)
+        status = verify(entry, models_dir)
+        icon = {"ok": "✅", "missing": "⬇️", "corrupt": "⚠️", "unverified": "❔"}[status]
+        console.print(f"{icon} [{pname}] {entry.rel}: {status}")
+        if status == "corrupt":
+            bad += 1
+    if bad:
+        raise typer.Exit(code=1)
+
+
+def main() -> None:
+    from aioli_cli import _plugins
+
+    _plugins.load_all()
+    registry.attach(app)
+    app()
+
+
+if __name__ == "__main__":
+    main()

aioli_cli/registry.py

@@ -0,0 +1,45 @@
+"""Plugin registry. Each modality registers a Typer app + metadata."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+import typer
+
+from aioli_contract.doctor import Check
+
+
+@dataclass
+class Plugin:
+    name: str
+    description: str
+    app: typer.Typer = field(default_factory=typer.Typer)
+    checks: Callable[[], list[Check]] | None = None
+    models: Callable[[], list[dict]] | None = None
+    gated_note: str = ""
+    default_backend: str = ""
+
+
+class Registry:
+    def __init__(self) -> None:
+        self._plugins: dict[str, Plugin] = {}
+
+    def register(self, plugin: Plugin) -> None:
+        if plugin.name in self._plugins:
+            raise ValueError(f"plugin already registered: {plugin.name}")
+        self._plugins[plugin.name] = plugin
+
+    def names(self) -> list[str]:
+        return sorted(self._plugins)
+
+    def all(self) -> list[Plugin]:
+        return [self._plugins[name] for name in self.names()]
+
+    def attach(self, app: typer.Typer) -> None:
+        for name in self.names():
+            plugin = self._plugins[name]
+            app.add_typer(plugin.app, name=name, help=plugin.description)
+
+
+registry = Registry()

aioli_cli/setup.py

@@ -0,0 +1,151 @@
+"""`aioli setup`: pretty first-run wizard (probe → advise → download)."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+console = Console()
+
+LEAGUE_LINES = {
+    "patata": "🥔 Sin NVIDIA a la vista: tiraremos de CPU (voice) y poco más.",
+    "modesta": "🛵 GPU modesta: motores ligeros y sin prisas.",
+    "capaz": "💪 GPU capaz: el set default corre bien.",
+    "bicha": "🔥 Menuda bicha: todo el set default sobrado.",
+}
+
+
+def _load():
+    from aioli_cli import _plugins  # noqa: PLC0415
+    from aioli_cli.registry import registry  # noqa: PLC0415
+
+    _plugins.load_all()
+    return registry
+
+
+def machine_panel(machine) -> Panel:
+    lines = []
+    if machine.gpus:
+        for g in machine.gpus:
+            lines.append(f"🎮 {g.name} — {g.total_gb:.0f} GB ({g.free_gb:.0f} libres)")
+    else:
+        lines.append("🎮 sin GPU NVIDIA")
+    lines.append(f"🧠 RAM: {machine.ram_gb:.0f} GB   💾 disco libre: {machine.disk_free_gb:.0f} GB")
+    lines.append("")
+    lines.append(LEAGUE_LINES[machine.league])
+    return Panel("\n".join(lines), title="🧄 aioli setup — tu equipo", border_style="yellow")
+
+
+def verdict_table(registry, machine) -> Table:
+    from aioli_contract.advise import judge
+
+    table = Table(title="¿Qué corre aquí?")
+    table.add_column("plugin")
+    table.add_column("motor")
+    table.add_column("")
+    table.add_column("veredicto")
+    for p in registry.all():
+        if p.models is None:
+            continue
+        engines = sorted({e.get("backend", "?") for e in p.models()})
+        for engine in engines:
+            v = judge(p.name, engine, machine)
+            table.add_row(p.name, engine, v.icon, v.headline + (f"\n[yellow]{v.detail}[/yellow]" if v.detail else ""))
+    return table
+
+
+def run_setup(yes: bool = False, plugins: str | None = None) -> None:
+    from aioli_contract import ModelFile, default_models_dir, download, human_gb, verify
+    from aioli_contract.advise import judge, read_machine
+    from rich.progress import Progress
+
+    registry = _load()
+    models_dir = default_models_dir()
+    machine = read_machine(models_dir)
+
+    console.print()
+    console.print(machine_panel(machine))
+    console.print()
+    console.print(verdict_table(registry, machine))
+    console.print()
+
+    # Candidate set: default backend of each plugin that fits (✅/⚠️).
+    candidates: list[tuple[str, ModelFile]] = []
+    for p in registry.all():
+        if p.models is None:
+            continue
+        for raw in p.models():
+            entry = ModelFile(**raw)
+            if entry.backend != (p.default_backend or entry.backend):
+                continue
+            if entry.optional:
+                continue
+            v = judge(p.name, entry.backend, machine)
+            if v.fits:
+                candidates.append((p.name, entry))
+
+    by_plugin: dict[str, list[ModelFile]] = {}
+    for pname, entry in candidates:
+        by_plugin.setdefault(pname, []).append(entry)
+
+    if plugins:
+        chosen = [p.strip() for p in plugins.split(",") if p.strip()]
+    elif yes:
+        chosen = sorted(by_plugin)
+    else:
+        options = ", ".join(
+            f"{pn} ({human_gb(sum(e.size for e in es))})" for pn, es in sorted(by_plugin.items())
+        )
+        answer = Prompt.ask(
+            f"¿Qué instalo? [{options}]",
+            default=",".join(sorted(by_plugin)),
+        )
+        chosen = [p.strip() for p in answer.split(",") if p.strip()]
+
+    wanted = [(pn, e) for pn, e in candidates if pn in chosen]
+    missing = [(pn, e) for pn, e in wanted if verify(e, models_dir) != "ok"]
+    if not missing:
+        console.print(Panel("✅ Todo lo elegido ya está descargado y verificado.", border_style="green"))
+        return
+
+    total = sum(e.size for _, e in missing)
+    console.print(f"⬇️  {len(missing)} ficheros, {human_gb(total)} → {models_dir}")
+    notes = {registry._plugins[pn].gated_note for pn, _ in missing}
+    for note in sorted(n for n in notes if n):
+        console.print(f"🔑 {note}")
+    if not yes and not Confirm.ask("¿Descargo ahora?", default=True):
+        raise typer.Abort()
+
+    class _Bar:
+        def __init__(self, progress: Progress) -> None:
+            self.progress = progress
+            self.tasks: dict[str, int] = {}
+
+        def update(self, path, done_bytes: int, total_bytes: int) -> None:
+            key = str(path)
+            task = self.tasks.get(key)
+            if task is None:
+                task = self.progress.add_task(path.name, total=total_bytes or 1)
+                self.tasks[key] = task
+            self.progress.update(task, completed=done_bytes, total=total_bytes or 1)
+
+    with Progress() as progress:
+        for _pn, entry in missing:
+            try:
+                download(entry, models_dir, progress=_Bar(progress))
+            except (IOError, ValueError) as exc:
+                console.print(f"❌ {entry.rel}: {exc}")
+                raise typer.Abort() from exc
+
+    console.print(
+        Panel(
+            "✅ Listo. Prueba:\n"
+            "  aioli doctor\n"
+            '  aioli image generate "un faro en tormenta" -o faro.png',
+            title="🧄 a generar",
+            border_style="green",
+        )
+    )

aioli_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.5
+Name: aioli-cli
+Version: 0.1.0
+Summary: aioli — local-first AI media suite CLI
+Author: aioli contributors
+License: MIT
+Keywords: ai,generative,image,local-first,music,tts,video
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia
+Requires-Python: >=3.12
+Requires-Dist: aioli-contract
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.9
+Description-Content-Type: text/markdown
+
+# aioli (see root README)

aioli_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+aioli_cli/_plugins.py,sha256=e6PbLZ5ZC8hwYO-aSWjGNqXmkJaLfRte-KJdU5rFVAA,3734
+aioli_cli/main.py,sha256=wl3DlcT1CWetRlMBCGnRsLrTYda7XTHxrUEudvOJt5I,7639
+aioli_cli/registry.py,sha256=iCx4TPJBjnkwqWh6c67igoA5Vx_0vyYGgnnBmuOohto,1215
+aioli_cli/setup.py,sha256=QXgHHzdNMo2C_w9wB55MkndEoLn2CyXT2X6zTG6oTyk,5347
+aioli_cli-0.1.0.dist-info/METADATA,sha256=qIaGh4bj8U_zsOtt9LKWHHQmBXCEPRfVjjjvet8iUcU,550
+aioli_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+aioli_cli-0.1.0.dist-info/entry_points.txt,sha256=XMf3mcJqGsedAQELaeg97uvrMU9LEoGeksbIzXZVpf0,46
+aioli_cli-0.1.0.dist-info/RECORD,,

aioli_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

aioli_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aioli = aioli_cli.main:main