aioli-cli 0.1.35__tar.gz → 0.1.37__tar.gz

{aioli_cli-0.1.35 → aioli_cli-0.1.37}/PKG-INFO

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

{aioli_cli-0.1.35 → aioli_cli-0.1.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioli-cli"
-version = "0.1.35"
+version = "0.1.37"
 description = "aioli — local-first AI media suite CLI (images, video, music, voice, podcast)"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -112,6 +112,11 @@ testpaths = [
     "plugins/master/tests",
 ]
 addopts = "-q"
+# Markers: "network" sube a upstream real (gasta red y disco). Opt-in via
+# AIOLI_NET_TESTS=1, lo activa el job smoke-bundles de release.yml.
+markers = [
+    "network: baja del asset real de upstream (gasta red); opt-in",
+]
 
 [dependency-groups]
 dev = [

{aioli_cli-0.1.35 → aioli_cli-0.1.37}/src/aioli_music/models_data.py

@@ -73,8 +73,8 @@ MODELS: list[dict] = [
         "name": "audiocpp_cli runtime (linux x86_64 CUDA, motor yue2)",
         "rel": "audiocpp/audiocpp_cli",
         "url": "https://github.com/damenordev/aioli-runtimes/releases/download/runtimes-v4/audiocpp-linux-x86_64-cuda.tar.gz",
-        "sha256": "296ce2c94a4c429dc7ba84e6f5374662d6515512868c7b78dd4a095eaf08453f",
-        "size": 14403139,
+        "sha256": "8400328308f7b3a3174c0306c5be13affd1da47f84a52f18f25d4c137707f2da",
+        "size": 677061646,
         "backend": "yue2",
         "role": "runtime",
         "kind": "runtime",

{aioli_cli-0.1.35 → aioli_cli-0.1.37}/src/aioli_podcast/cast.py

@@ -14,6 +14,13 @@ from pathlib import Path
 import numpy as np
 import soundfile as sf
 
+CAST_HINT = (
+    "aioli voice profiles create podcast-{role} --language es && "
+    'aioli voice profiles add-sample podcast-{role} muestra.wav -t "transcripción" '
+    "(o --cast ROL=muestra.wav|@perfil)"
+)
+"""Shared actionable hint (episode.py delegates its no-sample error here)."""
+
 
 def sine_reference(
     path: Path, hz: float = 220.0, seconds: float = 3.0, sample_rate: int = 22_050
@@ -33,24 +40,42 @@ def ensure_role_profile(
 
     `sample` forms:
       - `@profilename` — reuse an existing voice profile (no new samples).
-      - path to a wav(/mp3) reference sample.
+      - path to a wav(/mp3) reference sample (piper: `.onnx` voice file).
+
+    Same role always maps to the same profile id (consistent voice);
+    different roles map to different profiles. Without a sample or an
+    existing profile the caller must fail loudly with an actionable hint
+    (never a silent sine fallback — sine lives only in the stub path of
+    `episode.build_episode`).
     """
     from aioli_voice.core.profiles import ProfileStore
 
+    hint = CAST_HINT.format(role=role.lower())
     with ProfileStore(settings) as store:
         if sample is not None and str(sample).startswith("@"):
             want = str(sample)[1:]
             for entry in store.list_profiles():
                 if entry.name == want:
                     return entry.id
-            raise ValueError(f"perfil de voz {want!r} no existe (rol {role})")
+            raise ValueError(f"perfil de voz {want!r} no existe (rol {role}); {hint}")
+        if sample is None:
+            for entry in store.list_profiles():
+                if entry.name == f"podcast-{role.lower()}":
+                    if store.list_samples(entry.id):
+                        return entry.id
+            raise ValueError(f"rol {role}: sin muestra ni perfil de voz; {hint}")
+        sample_path = Path(str(sample))
+        if not sample_path.exists():
+            raise ValueError(f"rol {role}: muestra {sample} no encontrada; {hint}")
         for entry in store.list_profiles():
             if entry.name == f"podcast-{role.lower()}":
+                # A new sample is never ignored: add it to the existing
+                # profile (ProfileStore dedupes by sha256, so re-adding
+                # the same file is a no-op).
+                store.add_sample(entry.id, sample_path, transcript)
                 return entry.id
         profile_id = store.add_profile(f"podcast-{role.lower()}", language="es")
-        if sample is None:
-            raise ValueError(f"rol {role}: sin muestra y sin referencia sintética")
-        store.add_sample(profile_id, sample, transcript)
+        store.add_sample(profile_id, sample_path, transcript)
         return profile_id
 
 

aioli_cli-0.1.37/src/aioli_podcast/cli.py

@@ -0,0 +1,118 @@
+"""Typer CLI for the aioli `podcast` plugin (episode orchestrator)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from .episode import PAUSE_DEFAULT_S, build_episode, parse_role_gains
+from .script import parse_script
+
+app = typer.Typer(
+    name="podcast", help="Episode orchestrator: script → voices + bed → mp3.", no_args_is_help=True
+)
+
+
+@app.command(name="episode")
+def episode(
+    script: Path = typer.Argument(..., help="Markdown script ([ROL] lines)."),
+    out_dir: Path = typer.Option(Path("episodio"), "--out-dir", "-o"),
+    cast: list[str] | None = typer.Option(None, "--cast", help="ROL=muestra.wav (repeatable)."),
+    gain: list[str] | None = typer.Option(
+        None, "--gain", help="ROL=dB balance por rol (repetible, clamp ±12 dB)."
+    ),
+    voice_engine: str = typer.Option("stub", "--voice-engine", help="Voice engine (stub offline)."),
+    bed_backend: str = typer.Option("stub", "--bed", help="Music backend (stub offline)."),
+    bed_desc: str | None = typer.Option(
+        None, "--bed-desc", help="Bed description (overrides [MUSIC])."
+    ),
+    bed_file: Path | None = typer.Option(
+        None, "--bed-file", help="Use this audio as bed (looped)."
+    ),
+    bed_mode: str = typer.Option("edges", "--bed-mode", help="edges (intro/outro) | full | off."),
+    pause_default: float = typer.Option(
+        PAUSE_DEFAULT_S,
+        "--pause-default",
+        help="Gap inter-línea natural en segundos (0 lo desactiva).",
+    ),
+) -> None:
+    """Render a full episode: mp3 + timeline.json + shownotes.md."""
+    from aioli_voice.config.settings import VoiceSettings
+
+    parsed = parse_script(script)
+    try:
+        role_gains = parse_role_gains(gain)
+    except ValueError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(2) from None
+    cast_samples: dict[str, Path] = {}
+    for item in cast or []:
+        role, _, wav = item.partition("=")
+        if not role or not wav:
+            typer.echo(f"--cast debe ser ROL=muestra.wav (recibido {item!r})", err=True)
+            raise typer.Exit(2)
+        cast_samples[role.upper()] = Path(wav)
+
+    known_roles = {r.upper() for r in parsed.roles}
+    for flag, parsed_map in (("--cast", cast_samples), ("--gain", role_gains)):
+        unknown = sorted(set(parsed_map) - known_roles)
+        if unknown:
+            typer.echo(
+                f"{flag}: rol(es) {', '.join(unknown)} no están en el guion "
+                f"(roles: {', '.join(sorted(known_roles)) or 'ninguno'})",
+                err=True,
+            )
+            raise typer.Exit(2)
+
+    out = out_dir if out_dir.is_absolute() else Path.cwd() / out_dir
+    # Shared voice store: --cast @perfil reuses your real profiles.
+    settings = VoiceSettings.load()
+    settings.ensure_dirs()
+    result = build_episode(
+        parsed,
+        out,
+        settings,
+        cast_samples,
+        voice_engine,
+        role_gains,
+        bed_backend,
+        bed_desc,
+        bed_file,
+        bed_mode,
+        pause_default=pause_default,
+    )
+    typer.echo(f"🎙️ {result.mp3} ({result.duration_s:.1f}s, {result.lines} líneas)")
+    typer.echo(f"   {result.timeline}\n   {result.shownotes}")
+
+
+@app.command(name="feed")
+def feed(
+    dir: Path = typer.Argument(..., help="Directorio con episodios (mp3+timeline)."),
+    base_url: str | None = typer.Option(
+        None, "--base-url", help="URL pública antepuesta a los enclosures."
+    ),
+    title: str | None = typer.Option(None, "--title", help="Título del canal."),
+    link: str | None = typer.Option(None, "--link", help="Link del canal."),
+    description: str | None = typer.Option(None, "--description", help="Descripción del canal."),
+) -> None:
+    """Genera feed.xml local escaneando episodios (mp3+timeline) del dir."""
+    from .feed import build_feed
+
+    target = dir if dir.is_absolute() else Path.cwd() / dir
+    feed_path = build_feed(target, base_url, title, link, description)
+    typer.echo(f"📡 {feed_path}")
+    if not base_url:
+        typer.echo(
+            "Hint: las apps externas necesitan una URL pública; "
+            "usa --base-url https://tu-dominio/episodios",
+            err=True,
+        )
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

{aioli_cli-0.1.35 → aioli_cli-0.1.37}/src/aioli_podcast/episode.py

@@ -37,33 +37,108 @@ def _silence(path: Path, seconds: float, sample_rate: int = 48_000) -> Path:
     return path
 
 
-def _cut_murmur_tail(path: Path, sample_rate: int = 24_000) -> float:
-    """Cut cross-lingual babble tail: first long near-silence after 40%.
+PAUSE_DEFAULT_S = 0.35
+"""Default inter-line natural gap in seconds (AC4: within 0.25-0.6s)."""
+
+
+def _cut_murmur_tail(
+    path: Path,
+    sample_rate: int = 24_000,
+    silence_s: float = 0.35,
+    rms_threshold: float = 0.01,
+    start_ratio: float = 0.4,
+    window_s: float = 0.1,
+) -> float:
+    """Cut a trailing near-silence tail; never cut a mid-line pause.
 
     qwen3 with a foreign reference keeps mumbling after the sentence.
-    Returns the kept duration (file rewritten in place if cut)."""
+    The clip is rewritten in place ONLY when its tail — scanned backwards
+    from the end — is a contiguous near-silence run (RMS below
+    `rms_threshold`) of at least `silence_s` seconds that starts after
+    `start_ratio` of the line. A natural mid-line pause followed by more
+    voice (voice→pause→voice) is preserved intact. Returns the kept
+    duration. `sample_rate` is kept for backward compatibility and
+    ignored (the file's own rate is used)."""
     import numpy as np
     import soundfile as sf
 
+    _ = sample_rate
     x, sr = sf.read(str(path))
     mono = x.mean(axis=1) if x.ndim > 1 else x
-    win = int(sr * 0.1)
-    start = int(len(mono) * 0.4)
-    quiet = int(sr * 0.35)
-    run = 0
-    cut_at = len(mono)
-    for i in range(start, len(mono), win):
-        seg = mono[i : i + win]
-        if np.sqrt((seg**2).mean()) < 0.01:
-            run += len(seg)
-            if run >= quiet:
-                cut_at = i + win - run
-                break
+    win = max(1, int(sr * window_s))
+    quiet = int(sr * silence_s)
+    # Trailing quiet run: windows scanned from the end, stop at first voice.
+    tail_quiet = 0
+    for end in range(len(mono), 0, -win):
+        seg = mono[max(0, end - win) : end]
+        if np.sqrt((seg**2).mean()) < rms_threshold:
+            tail_quiet += len(seg)
         else:
-            run = 0
-    if cut_at < len(mono):
+            break
+    cut_at = len(mono) - tail_quiet
+    if tail_quiet >= quiet and cut_at >= int(len(mono) * start_ratio):
         sf.write(str(path), x[:cut_at], sr)
-    return cut_at / sr
+        return cut_at / sr
+    return len(mono) / sr
+
+
+def _next_dialogue_follows(blocks: list, index: int) -> bool:
+    """True when the next substantive block (skipping Music beds) is Dialogue."""
+    for later in blocks[index + 1 :]:
+        if isinstance(later, Music):
+            continue
+        return isinstance(later, Dialogue)
+    return False
+
+
+ROLE_GAIN_LIMIT_DB = 12.0
+
+
+def _clamp_gain_db(db: float) -> float:
+    return max(-ROLE_GAIN_LIMIT_DB, min(ROLE_GAIN_LIMIT_DB, db))
+
+
+def parse_role_gains(items: list[str] | None) -> dict[str, float]:
+    """Parse `--gain ROL=dB` (repeatable) into `{ROL: dB}` clamped to ±12 dB."""
+    gains: dict[str, float] = {}
+    for item in items or []:
+        role, sep, raw = item.partition("=")
+        if not role or not sep:
+            raise ValueError(f"--gain debe ser ROL=dB (recibido {item!r})")
+        try:
+            db = float(raw)
+        except ValueError:
+            raise ValueError(f"--gain debe ser ROL=dB (recibido {item!r})") from None
+        gains[role.strip().upper()] = _clamp_gain_db(db)
+    return gains
+
+
+def apply_gain_db(inp: Path, out: Path, db: float) -> Path:
+    """Apply `db` gain (clamped ±12 dB) with a peak limiter (< 0 dBFS)."""
+    import numpy as np
+    import soundfile as sf
+
+    db = _clamp_gain_db(db)
+    x, sr = sf.read(str(inp), dtype="float32")
+    y = np.asarray(x, dtype=np.float32) * float(10.0 ** (db / 20.0))
+    peak = float(np.abs(y).max()) if y.size else 0.0
+    if peak >= 1.0:
+        y = (y * (0.99 / peak)).astype(np.float32)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    sf.write(str(out), y, sr)
+    return out
+
+
+def _peak_limit_wav(path: Path, ceiling: float = 0.99) -> None:
+    """In-place peak normalize so the file never clips (peak < 0 dBFS)."""
+    import numpy as np
+    import soundfile as sf
+
+    x, sr = sf.read(str(path), dtype="float32")
+    arr = np.asarray(x, dtype=np.float32)
+    peak = float(np.abs(arr).max()) if arr.size else 0.0
+    if peak >= 1.0:
+        sf.write(str(path), (arr * (ceiling / peak)).astype(np.float32), sr)
 
 
 def build_episode(
@@ -72,10 +147,12 @@ def build_episode(
     voice_settings,
     cast_samples: dict[str, Path] | None = None,
     voice_engine: str = "stub",
+    role_gains: dict[str, float] | None = None,
     bed_backend: str = "stub",
     bed_desc: str | None = None,
     bed_file: Path | None = None,
     bed_mode: str = "edges",
+    pause_default: float = PAUSE_DEFAULT_S,
 ) -> EpisodeResult:
     """Run the full pipeline. Returns paths + stats."""
     from aioli_master import ops
@@ -87,11 +164,19 @@ def build_episode(
     work.mkdir(exist_ok=True)
 
     service = GenerationService(voice_settings)
+    gains = {str(r).upper(): _clamp_gain_db(float(v)) for r, v in (role_gains or {}).items()}
     profile_ids: dict[str, int] = {}
     for i, role in enumerate(script.roles):
         sample = cast_samples.get(role)
         if sample is None:
-            sample = cast.sine_reference(work / f"ref-{role.lower()}.wav", hz=180.0 + 40.0 * i)
+            if voice_engine == "stub":
+                sample = cast.sine_reference(work / f"ref-{role.lower()}.wav", hz=180.0 + 40.0 * i)
+            else:
+                # Real engine without --cast: resolve the existing
+                # `podcast-<role>` profile or fail loudly with the shared
+                # actionable hint (delegated, never a silent sine fallback).
+                profile_ids[role] = cast.ensure_role_profile(voice_settings, role, None)
+                continue
         profile_ids[role] = cast.ensure_role_profile(voice_settings, role, sample)
 
     # 1-2. Speak every line.
@@ -124,6 +209,18 @@ def build_episode(
             print(f"  [trim] {raw.name} → {kept:.1f}s")
             prep = work / f"line-{n:03d}-48.wav"
             ops.run(ops.convert_argv(raw, prep))
+            db = gains.get(block.role.upper(), 0.0)
+            if db:
+                gained = work / f"line-{n:03d}-48-g.wav"
+                apply_gain_db(prep, gained, db)
+                prep = gained
+            if pause_default > 0 and _next_dialogue_follows(script.blocks, n):
+                pad_raw = _silence(work / f"pad-{n}.wav", pause_default)
+                pad48 = work / f"pad-{n}-48.wav"
+                ops.run(ops.convert_argv(pad_raw, pad48))
+                padded = work / f"line-{n:03d}-48-p.wav"
+                ops.run(ops.concat_argv([prep, pad48], padded))
+                prep = padded
             dur = ops.info(prep)["duration_s"]
             timeline.append(
                 {
@@ -139,6 +236,7 @@ def build_episode(
 
     voices = work / "voices.wav"
     ops.run(ops.concat_argv(parts, voices))
+    _peak_limit_wav(voices)
 
     # 3-4. Bed + duck + loudnorm → mp3.
     mixed = voices

aioli_cli-0.1.37/src/aioli_podcast/feed.py

@@ -0,0 +1,189 @@
+"""Local RSS feed for podcast episodes (iTunes-compatible, offline).
+
+Reads episode dirs produced by `build_episode` (mp3 + timeline.json +
+shownotes.md) and writes `feed.xml`. Without `--base-url` the enclosures
+are absolute `file://` URLs (only local players can fetch them); with a
+base URL it is prepended so external apps can subscribe.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from email.utils import formatdate
+from pathlib import Path
+
+ITUNES_NS = "http://www.itunes.com/dtds/podcast-1.0.dtd"
+ATOM_NS = "http://www.w3.org/2005/Atom"
+
+ET.register_namespace("itunes", ITUNES_NS)
+ET.register_namespace("atom", ATOM_NS)
+
+
+@dataclass
+class FeedEpisode:
+    title: str
+    mp3: Path
+    url: str
+    length: int
+    pub_date: str
+    duration: str
+    description: str
+    guid: str
+
+
+def format_duration(seconds: float) -> str:
+    """Format seconds as HH:MM:SS for `itunes:duration`."""
+    try:
+        total = max(0, int(round(float(seconds))))
+    except (TypeError, ValueError):
+        total = 0
+    h, rem = divmod(total, 3600)
+    m, s = divmod(rem, 60)
+    return f"{h:02d}:{m:02d}:{s:02d}"
+
+
+def _rfc822(mtime: float) -> str:
+    return formatdate(mtime, usegmt=True)
+
+
+def _episode_meta(
+    mp3: Path, sibling_dir: Path, base_url: str | None, url_path: str | None = None
+) -> FeedEpisode:
+    timeline_path = sibling_dir / "timeline.json"
+    if not timeline_path.exists():
+        alt = mp3.with_suffix(".json")
+        timeline_path = alt if alt.exists() else timeline_path
+    notes_path = sibling_dir / "shownotes.md"
+    if not notes_path.exists():
+        alt = mp3.with_suffix(".md")
+        notes_path = alt if alt.exists() else notes_path
+
+    title = mp3.stem
+    duration_s = 0.0
+    if timeline_path.exists():
+        try:
+            timeline = json.loads(timeline_path.read_text(encoding="utf-8"))
+            title = str(timeline.get("title") or title)
+            duration_s = float(timeline.get("duration_s") or 0.0)
+        except (ValueError, TypeError, AttributeError):
+            pass
+    description = ""
+    if notes_path.exists():
+        try:
+            description = notes_path.read_text(encoding="utf-8").strip()
+        except OSError:
+            pass
+
+    if base_url:
+        url = base_url.rstrip("/") + "/" + (url_path or mp3.name)
+    else:
+        url = mp3.resolve().as_uri()
+    stat = mp3.stat()
+    return FeedEpisode(
+        title=title,
+        mp3=mp3,
+        url=url,
+        length=stat.st_size,
+        pub_date=_rfc822(stat.st_mtime),
+        duration=format_duration(duration_s),
+        description=description,
+        guid=url,
+    )
+
+
+def collect_episodes(out_dir: Path, base_url: str | None = None) -> list[FeedEpisode]:
+    """Scan `out_dir` for episodes (mp3 + timeline) — itself or subdirs."""
+    out_dir = out_dir.resolve()
+    mp3s: list[Path] = sorted(out_dir.glob("*.mp3"))
+    for sub in sorted(p for p in out_dir.iterdir() if p.is_dir()):
+        mp3s.extend(sorted(sub.glob("*.mp3")))
+    return [
+        _episode_meta(mp3, mp3.parent, base_url, mp3.relative_to(out_dir).as_posix())
+        for mp3 in mp3s
+    ]
+
+
+def build_feed(
+    out_dir: Path | list[Path],
+    base_url: str | None = None,
+    title: str | None = None,
+    link: str | None = None,
+    description: str | None = None,
+) -> Path:
+    """Build `feed.xml` for episodes under `out_dir` (or an episodes list).
+
+    Returns the feed.xml path. Channel tags: title, link, description,
+    language es-ES, itunes:author, itunes:explicit false, itunes:category,
+    atom:link self. Items carry title, HTML-escaped shownotes description,
+    pubDate RFC822, enclosure url/length/type audio/mpeg, guid
+    isPermaLink=false and itunes:duration HH:MM:SS.
+    """
+    if isinstance(out_dir, list):
+        items = [Path(m).resolve() for m in out_dir]
+        mp3s: list[Path] = []
+        for entry in items:
+            if entry.is_dir():
+                mp3s.extend(sorted(entry.glob("*.mp3")))
+            elif entry.is_file():
+                mp3s.append(entry)
+        try:
+            common = Path(os.path.commonpath([str(i) for i in items]))
+        except ValueError:
+            common = None
+        episodes = []
+        for mp3 in sorted(mp3s):
+            try:
+                rel = mp3.relative_to(common).as_posix() if common else None
+            except ValueError:
+                rel = None
+            episodes.append(_episode_meta(mp3, mp3.parent, base_url, rel))
+        if out_dir:
+            target = Path(str(out_dir[0])).resolve()
+            target = (target.parent if target.is_file() else target) / "feed.xml"
+        else:
+            target = Path("feed.xml")
+        feed_dir = target.parent
+    else:
+        feed_dir = Path(out_dir).resolve()
+        episodes = collect_episodes(feed_dir, base_url)
+        target = feed_dir / "feed.xml"
+
+    channel_title = title or (episodes[0].title if len(episodes) == 1 else "Aioli Podcast")
+    channel_link = link or (base_url.rstrip("/") if base_url else feed_dir.as_uri())
+    channel_desc = description or "Feed local generado por aioli podcast."
+    self_href = base_url.rstrip("/") + "/feed.xml" if base_url else target.resolve().as_uri()
+
+    rss = ET.Element("rss", {"version": "2.0"})
+    channel = ET.SubElement(rss, "channel")
+    ET.SubElement(channel, "title").text = channel_title
+    ET.SubElement(channel, "link").text = channel_link
+    ET.SubElement(channel, "description").text = channel_desc
+    ET.SubElement(channel, "language").text = "es-ES"
+    ET.SubElement(channel, f"{{{ITUNES_NS}}}author").text = channel_title
+    ET.SubElement(channel, f"{{{ITUNES_NS}}}explicit").text = "false"
+    ET.SubElement(channel, f"{{{ITUNES_NS}}}category", {"text": "Society & Culture"})
+    ET.SubElement(
+        channel,
+        f"{{{ATOM_NS}}}link",
+        {"href": self_href, "rel": "self", "type": "application/rss+xml"},
+    )
+    for ep in episodes:
+        item_el = ET.SubElement(channel, "item")
+        ET.SubElement(item_el, "title").text = ep.title
+        ET.SubElement(item_el, "description").text = ep.description
+        ET.SubElement(item_el, "pubDate").text = ep.pub_date
+        ET.SubElement(
+            item_el,
+            "enclosure",
+            {"url": ep.url, "length": str(ep.length), "type": "audio/mpeg"},
+        )
+        ET.SubElement(item_el, "guid", {"isPermaLink": "false"}).text = ep.guid
+        ET.SubElement(item_el, f"{{{ITUNES_NS}}}duration").text = ep.duration
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    tree = ET.ElementTree(rss)
+    tree.write(str(target), encoding="utf-8", xml_declaration=True)
+    return target

aioli_cli-0.1.35/src/aioli_podcast/cli.py

@@ -1,60 +0,0 @@
-"""Typer CLI for the aioli `podcast` plugin (episode orchestrator)."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import typer
-
-from .episode import build_episode
-from .script import parse_script
-
-app = typer.Typer(
-    name="podcast", help="Episode orchestrator: script → voices + bed → mp3.", no_args_is_help=True
-)
-
-
-@app.command(name="episode")
-def episode(
-    script: Path = typer.Argument(..., help="Markdown script ([ROL] lines)."),
-    out_dir: Path = typer.Option(Path("episodio"), "--out-dir", "-o"),
-    cast: list[str] | None = typer.Option(None, "--cast", help="ROL=muestra.wav (repeatable)."),
-    voice_engine: str = typer.Option("stub", "--voice-engine", help="Voice engine (stub offline)."),
-    bed_backend: str = typer.Option("stub", "--bed", help="Music backend (stub offline)."),
-    bed_desc: str | None = typer.Option(
-        None, "--bed-desc", help="Bed description (overrides [MUSIC])."
-    ),
-    bed_file: Path | None = typer.Option(
-        None, "--bed-file", help="Use this audio as bed (looped)."
-    ),
-    bed_mode: str = typer.Option("edges", "--bed-mode", help="edges (intro/outro) | full | off."),
-) -> None:
-    """Render a full episode: mp3 + timeline.json + shownotes.md."""
-    from aioli_voice.config.settings import VoiceSettings
-
-    parsed = parse_script(script)
-    cast_samples: dict[str, Path] = {}
-    for item in cast or []:
-        role, _, wav = item.partition("=")
-        if not role or not wav:
-            typer.echo(f"--cast debe ser ROL=muestra.wav (recibido {item!r})", err=True)
-            raise typer.Exit(2)
-        cast_samples[role.upper()] = Path(wav)
-
-    out = out_dir if out_dir.is_absolute() else Path.cwd() / out_dir
-    # Shared voice store: --cast @perfil reuses your real profiles.
-    settings = VoiceSettings.load()
-    settings.ensure_dirs()
-    result = build_episode(
-        parsed, out, settings, cast_samples, voice_engine, bed_backend, bed_desc, bed_file, bed_mode
-    )
-    typer.echo(f"🎙️ {result.mp3} ({result.duration_s:.1f}s, {result.lines} líneas)")
-    typer.echo(f"   {result.timeline}\n   {result.shownotes}")
-
-
-def main() -> None:
-    app()
-
-
-if __name__ == "__main__":
-    main()