elidia-agent-cli 0.1.0__py3-none-any.whl

elidia/creative/audio.py

@@ -0,0 +1,213 @@
+"""Audio generation via AiUtils Developer API.
+
+Text-to-speech (ElevenLabs, OpenAI TTS) and music generation (Suno).
+"""
+from __future__ import annotations
+
+import base64
+import logging
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from elidia.api.client import AiUtilsClient
+
+logger = logging.getLogger(__name__)
+
+TTS_MODELS = {
+    "elevenlabs-v2": {"vendor": "elevenlabs", "voices": ["rachel", "adam", "josh", "bella", "elli"]},
+    "tts-1": {"vendor": "openai", "voices": ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]},
+    "tts-1-hd": {"vendor": "openai", "voices": ["alloy", "echo", "fable", "onyx", "nova", "shimmer"]},
+}
+
+MUSIC_MODELS = {
+    "suno-v4": {"vendor": "suno", "max_duration": 240},
+}
+
+DEFAULT_TTS_MODEL = "tts-1"
+DEFAULT_MUSIC_MODEL = "suno-v4"
+DEFAULT_OUTPUT_DIR = Path.home() / ".elidia" / "generated" / "audio"
+
+
+@dataclass
+class AudioResult:
+    file_path: str
+    model: str
+    text: str
+    voice: str
+    format: str = "mp3"
+    size_bytes: int = 0
+    elapsed_ms: int = 0
+
+
+@dataclass
+class MusicResult:
+    file_path: str
+    model: str
+    prompt: str
+    duration: int
+    format: str = "mp3"
+    size_bytes: int = 0
+    elapsed_ms: int = 0
+
+
+async def generate_speech(
+    client: AiUtilsClient,
+    text: str,
+    model: str = DEFAULT_TTS_MODEL,
+    voice: str = "alloy",
+    output_dir: Path | None = None,
+) -> AudioResult:
+    logger.debug(f"Entered into generate_speech: model={model}, voice={voice}, text_len={len(text)}")
+    start = time.monotonic()
+
+    save_dir = output_dir or DEFAULT_OUTPUT_DIR
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "input": text,
+        "voice": voice,
+        "response_format": "mp3",
+    }
+
+    async with httpx.AsyncClient(
+        base_url=client._base_url,
+        headers={
+            "Authorization": f"Bearer {client._api_key}",
+            "Content-Type": "application/json",
+        },
+        timeout=httpx.Timeout(60.0, connect=10.0),
+    ) as http:
+        response = await http.post("/audio/speech", json=payload)
+
+        if response.status_code == 401:
+            raise RuntimeError("Invalid API key for audio generation")
+        if response.status_code == 402:
+            raise RuntimeError("Insufficient balance for audio generation")
+        response.raise_for_status()
+
+        content_type = response.headers.get("content-type", "")
+
+        if "audio" in content_type or "octet-stream" in content_type:
+            audio_bytes = response.content
+        else:
+            data = response.json()
+            b64 = data.get("audio", data.get("data", ""))
+            if b64:
+                audio_bytes = base64.b64decode(b64)
+            else:
+                raise RuntimeError("No audio data in response")
+
+    timestamp = int(time.time())
+    safe_text = "".join(c if c.isalnum() or c in " -_" else "" for c in text[:30]).strip().replace(" ", "_")
+    filename = f"{timestamp}_{voice}_{safe_text}.mp3"
+    file_path = save_dir / filename
+    file_path.write_bytes(audio_bytes)
+
+    elapsed = int((time.monotonic() - start) * 1000)
+    logger.info(f"Speech generated: {file_path} ({len(audio_bytes)} bytes, {elapsed}ms)")
+
+    return AudioResult(
+        file_path=str(file_path),
+        model=model,
+        text=text,
+        voice=voice,
+        format="mp3",
+        size_bytes=len(audio_bytes),
+        elapsed_ms=elapsed,
+    )
+
+
+async def generate_music(
+    client: AiUtilsClient,
+    prompt: str,
+    model: str = DEFAULT_MUSIC_MODEL,
+    duration: int = 30,
+    output_dir: Path | None = None,
+) -> MusicResult:
+    logger.debug(f"Entered into generate_music: model={model}, prompt={prompt[:60]!r}")
+    start = time.monotonic()
+
+    save_dir = output_dir or DEFAULT_OUTPUT_DIR
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    model_info = MUSIC_MODELS.get(model, MUSIC_MODELS[DEFAULT_MUSIC_MODEL])
+    duration = min(duration, model_info["max_duration"])
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "prompt": prompt,
+        "duration": duration,
+    }
+
+    async with httpx.AsyncClient(
+        base_url=client._base_url,
+        headers={
+            "Authorization": f"Bearer {client._api_key}",
+            "Content-Type": "application/json",
+        },
+        timeout=httpx.Timeout(120.0, connect=10.0),
+    ) as http:
+        response = await http.post("/audio/music", json=payload)
+
+        if response.status_code == 401:
+            raise RuntimeError("Invalid API key for music generation")
+        if response.status_code == 402:
+            raise RuntimeError("Insufficient balance for music generation")
+        response.raise_for_status()
+
+        content_type = response.headers.get("content-type", "")
+
+        if "audio" in content_type or "octet-stream" in content_type:
+            audio_bytes = response.content
+        else:
+            data = response.json()
+            b64 = data.get("audio", data.get("data", ""))
+            if b64:
+                audio_bytes = base64.b64decode(b64)
+            elif data.get("url"):
+                async with httpx.AsyncClient(timeout=60.0) as dl:
+                    dl_resp = await dl.get(data["url"])
+                    dl_resp.raise_for_status()
+                    audio_bytes = dl_resp.content
+            else:
+                raise RuntimeError("No audio data or URL in response")
+
+    timestamp = int(time.time())
+    safe_prompt = "".join(c if c.isalnum() or c in " -_" else "" for c in prompt[:30]).strip().replace(" ", "_")
+    filename = f"{timestamp}_music_{safe_prompt}.mp3"
+    file_path = save_dir / filename
+    file_path.write_bytes(audio_bytes)
+
+    elapsed = int((time.monotonic() - start) * 1000)
+    logger.info(f"Music generated: {file_path} ({len(audio_bytes)} bytes, {elapsed}ms)")
+
+    return MusicResult(
+        file_path=str(file_path),
+        model=model,
+        prompt=prompt,
+        duration=duration,
+        format="mp3",
+        size_bytes=len(audio_bytes),
+        elapsed_ms=elapsed,
+    )
+
+
+def list_tts_voices(model: str = DEFAULT_TTS_MODEL) -> list[str]:
+    logger.debug(f"Entered into list_tts_voices: model={model}")
+    info = TTS_MODELS.get(model, {})
+    return info.get("voices", [])
+
+
+def list_audio_models() -> list[dict[str, Any]]:
+    logger.debug("Entered into list_audio_models")
+    result: list[dict[str, Any]] = []
+    for name, info in TTS_MODELS.items():
+        result.append({"model": name, "type": "tts", "vendor": info["vendor"], "voices": info["voices"]})
+    for name, info in MUSIC_MODELS.items():
+        result.append({"model": name, "type": "music", "vendor": info["vendor"], "max_duration": info["max_duration"]})
+    return result

elidia/creative/display.py

@@ -0,0 +1,260 @@
+"""Terminal image display — protocol detection and inline rendering.
+
+Detects terminal capabilities and renders images inline using:
+  - iTerm2 inline images (OSC 1337)
+  - Kitty graphics protocol (ESC _G)
+  - Sixel graphics
+  - Fallback: save to file and print path
+"""
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import struct
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class TerminalProtocol(str, Enum):
+    ITERM2 = "iterm2"
+    KITTY = "kitty"
+    SIXEL = "sixel"
+    NONE = "none"
+
+
+@dataclass
+class DisplayResult:
+    protocol: TerminalProtocol
+    displayed: bool
+    file_path: str = ""
+    message: str = ""
+
+
+def detect_terminal() -> TerminalProtocol:
+    logger.debug("Entered into detect_terminal")
+
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    if term_program in ("iterm.app", "iterm2"):
+        return TerminalProtocol.ITERM2
+
+    if os.environ.get("KITTY_WINDOW_ID"):
+        return TerminalProtocol.KITTY
+
+    term = os.environ.get("TERM", "")
+    if "xterm" in term:
+        lc_terminal = os.environ.get("LC_TERMINAL", "").lower()
+        if lc_terminal == "iterm2":
+            return TerminalProtocol.ITERM2
+
+    if _check_sixel_support():
+        return TerminalProtocol.SIXEL
+
+    return TerminalProtocol.NONE
+
+
+def display_image(
+    image_path: str | Path,
+    max_width: int = 80,
+    max_height: int = 24,
+    protocol: TerminalProtocol | None = None,
+) -> DisplayResult:
+    logger.debug(f"Entered into display_image: path={image_path}")
+    path = Path(image_path)
+    if not path.exists():
+        return DisplayResult(
+            protocol=TerminalProtocol.NONE,
+            displayed=False,
+            file_path=str(path),
+            message=f"File not found: {path}",
+        )
+
+    proto = protocol or detect_terminal()
+    image_data = path.read_bytes()
+
+    if proto == TerminalProtocol.ITERM2:
+        return _display_iterm2(image_data, path, max_width)
+    elif proto == TerminalProtocol.KITTY:
+        return _display_kitty(image_data, path, max_width)
+    elif proto == TerminalProtocol.SIXEL:
+        return _display_sixel(image_data, path, max_width, max_height)
+    else:
+        return DisplayResult(
+            protocol=TerminalProtocol.NONE,
+            displayed=False,
+            file_path=str(path),
+            message=f"Image saved to: {path}",
+        )
+
+
+def _display_iterm2(data: bytes, path: Path, max_width: int) -> DisplayResult:
+    logger.debug(f"Entered into _display_iterm2: size={len(data)}")
+    b64 = base64.b64encode(data).decode("ascii")
+
+    filename = base64.b64encode(path.name.encode()).decode("ascii")
+    size = len(data)
+
+    seq = (
+        f"\033]1337;File=name={filename};size={size};"
+        f"inline=1;width=auto;height=auto;preserveAspectRatio=1:"
+        f"{b64}\a"
+    )
+
+    sys.stdout.write(seq)
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+    return DisplayResult(
+        protocol=TerminalProtocol.ITERM2,
+        displayed=True,
+        file_path=str(path),
+        message=f"Displayed via iTerm2 protocol ({len(data)} bytes)",
+    )
+
+
+def _display_kitty(data: bytes, path: Path, max_width: int) -> DisplayResult:
+    logger.debug(f"Entered into _display_kitty: size={len(data)}")
+    b64 = base64.b64encode(data).decode("ascii")
+
+    chunk_size = 4096
+    chunks = [b64[i:i + chunk_size] for i in range(0, len(b64), chunk_size)]
+
+    for i, chunk in enumerate(chunks):
+        is_last = i == len(chunks) - 1
+        more = 0 if is_last else 1
+
+        if i == 0:
+            header = f"a=T,f=100,m={more}"
+        else:
+            header = f"m={more}"
+
+        sys.stdout.write(f"\033_G{header};{chunk}\033\\")
+
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+    return DisplayResult(
+        protocol=TerminalProtocol.KITTY,
+        displayed=True,
+        file_path=str(path),
+        message=f"Displayed via Kitty protocol ({len(data)} bytes)",
+    )
+
+
+def _display_sixel(data: bytes, path: Path, max_width: int, max_height: int) -> DisplayResult:
+    logger.debug(f"Entered into _display_sixel: size={len(data)}")
+    try:
+        from PIL import Image
+    except ImportError:
+        return DisplayResult(
+            protocol=TerminalProtocol.SIXEL,
+            displayed=False,
+            file_path=str(path),
+            message="Sixel display requires Pillow: pip install Pillow",
+        )
+
+    try:
+        img = Image.open(path)
+
+        cell_w, cell_h = _get_cell_size()
+        max_px_w = max_width * cell_w
+        max_px_h = max_height * cell_h
+
+        w, h = img.size
+        if w > max_px_w or h > max_px_h:
+            ratio = min(max_px_w / w, max_px_h / h)
+            new_w = int(w * ratio)
+            new_h = int(h * ratio)
+            img = img.resize((new_w, new_h), Image.LANCZOS)
+
+        img = img.convert("P", palette=Image.ADAPTIVE, colors=256)
+
+        palette = img.getpalette()
+        pixels = list(img.getdata())
+        w, h = img.size
+
+        sixel_data = _encode_sixel(pixels, palette, w, h)
+
+        sys.stdout.write(f"\033P0;0;0q\"1;1;{w};{h}")
+        sys.stdout.write(sixel_data)
+        sys.stdout.write("\033\\")
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+
+        return DisplayResult(
+            protocol=TerminalProtocol.SIXEL,
+            displayed=True,
+            file_path=str(path),
+            message=f"Displayed via Sixel ({w}x{h})",
+        )
+    except Exception as e:
+        return DisplayResult(
+            protocol=TerminalProtocol.SIXEL,
+            displayed=False,
+            file_path=str(path),
+            message=f"Sixel encoding failed: {e}",
+        )
+
+
+def _encode_sixel(pixels: list[int], palette: list[int] | None, width: int, height: int) -> str:
+    logger.debug(f"Entered into _encode_sixel: {width}x{height}")
+    lines: list[str] = []
+
+    if palette:
+        for i in range(0, min(len(palette), 768), 3):
+            color_idx = i // 3
+            r = int(palette[i] / 255 * 100)
+            g = int(palette[i + 1] / 255 * 100)
+            b = int(palette[i + 2] / 255 * 100)
+            lines.append(f"#{color_idx};2;{r};{g};{b}")
+
+    for band_y in range(0, height, 6):
+        band_colors: dict[int, list[int]] = {}
+        for dy in range(6):
+            y = band_y + dy
+            if y >= height:
+                break
+            for x in range(width):
+                px = pixels[y * width + x]
+                if px not in band_colors:
+                    band_colors[px] = [0] * width
+                band_colors[px][x] |= 1 << dy
+
+        for color_idx, scanline in sorted(band_colors.items()):
+            lines.append(f"#{color_idx}")
+            for val in scanline:
+                lines.append(chr(63 + val))
+            lines.append("$")
+
+        lines.append("-")
+
+    return "".join(lines)
+
+
+def _check_sixel_support() -> bool:
+    logger.debug("Entered into _check_sixel_support")
+    term = os.environ.get("TERM", "")
+    if "sixel" in term.lower():
+        return True
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    if term_program in ("mlterm", "contour", "foot", "wezterm"):
+        return True
+    return False
+
+
+def _get_cell_size() -> tuple[int, int]:
+    logger.debug("Entered into _get_cell_size")
+    try:
+        import fcntl
+        import termios
+        result = fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, b"\x00" * 8)
+        rows, cols, xpixel, ypixel = struct.unpack("HHHH", result)
+        if xpixel > 0 and ypixel > 0 and cols > 0 and rows > 0:
+            return xpixel // cols, ypixel // rows
+    except Exception:
+        pass
+    return 8, 16

elidia/creative/image.py

@@ -0,0 +1,142 @@
+"""Image generation via AiUtils Developer API.
+
+Supports multiple models (FLUX, DALL-E, Stable Diffusion) through the
+unified /v1/images/generations endpoint. Saves generated images to disk
+and optionally displays them inline in supported terminals.
+"""
+from __future__ import annotations
+
+import base64
+import logging
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from elidia.api.client import AiUtilsClient
+
+logger = logging.getLogger(__name__)
+
+IMAGE_MODELS = {
+    "flux-1.1-pro": {"vendor": "bfl", "supports_size": True, "max_size": 2048},
+    "flux-schnell": {"vendor": "bfl", "supports_size": True, "max_size": 1024},
+    "dall-e-3": {"vendor": "openai", "supports_size": True, "max_size": 1792},
+    "dall-e-2": {"vendor": "openai", "supports_size": True, "max_size": 1024},
+    "sd-3.5-large": {"vendor": "stability", "supports_size": True, "max_size": 1024},
+    "sdxl-turbo": {"vendor": "stability", "supports_size": True, "max_size": 1024},
+}
+
+DEFAULT_MODEL = "flux-schnell"
+DEFAULT_OUTPUT_DIR = Path.home() / ".elidia" / "generated" / "images"
+
+
+@dataclass
+class ImageResult:
+    file_path: str
+    model: str
+    prompt: str
+    width: int
+    height: int
+    format: str = "png"
+    size_bytes: int = 0
+    elapsed_ms: int = 0
+    base64_data: str = ""
+
+
+async def generate_image(
+    client: AiUtilsClient,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    width: int = 1024,
+    height: int = 1024,
+    output_dir: Path | None = None,
+) -> ImageResult:
+    logger.debug(f"Entered into generate_image: model={model}, prompt={prompt[:60]!r}")
+    start = time.monotonic()
+
+    save_dir = output_dir or DEFAULT_OUTPUT_DIR
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    model_info = IMAGE_MODELS.get(model, IMAGE_MODELS[DEFAULT_MODEL])
+    max_size = model_info["max_size"]
+    width = min(width, max_size)
+    height = min(height, max_size)
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "prompt": prompt,
+        "n": 1,
+        "response_format": "b64_json",
+    }
+
+    if model_info["supports_size"]:
+        payload["size"] = f"{width}x{height}"
+
+    async with httpx.AsyncClient(
+        base_url=client._base_url,
+        headers={
+            "Authorization": f"Bearer {client._api_key}",
+            "Content-Type": "application/json",
+        },
+        timeout=httpx.Timeout(120.0, connect=10.0),
+    ) as http:
+        response = await http.post("/images/generations", json=payload)
+
+        if response.status_code == 401:
+            raise RuntimeError("Invalid API key for image generation")
+        if response.status_code == 402:
+            raise RuntimeError("Insufficient balance for image generation")
+        if response.status_code == 429:
+            raise RuntimeError("Rate limited — try again in a moment")
+        response.raise_for_status()
+
+        data = response.json()
+
+    images = data.get("data", [])
+    if not images:
+        raise RuntimeError("No image returned from API")
+
+    image_data = images[0]
+    b64 = image_data.get("b64_json", "")
+    if not b64:
+        url = image_data.get("url", "")
+        if url:
+            async with httpx.AsyncClient(timeout=30.0) as dl:
+                img_resp = await dl.get(url)
+                img_resp.raise_for_status()
+                img_bytes = img_resp.content
+        else:
+            raise RuntimeError("No image data or URL in response")
+    else:
+        img_bytes = base64.b64decode(b64)
+
+    timestamp = int(time.time())
+    safe_prompt = "".join(c if c.isalnum() or c in " -_" else "" for c in prompt[:40]).strip().replace(" ", "_")
+    filename = f"{timestamp}_{safe_prompt}.png"
+    file_path = save_dir / filename
+    file_path.write_bytes(img_bytes)
+
+    elapsed = int((time.monotonic() - start) * 1000)
+    logger.info(f"Image generated: {file_path} ({len(img_bytes)} bytes, {elapsed}ms)")
+
+    return ImageResult(
+        file_path=str(file_path),
+        model=model,
+        prompt=prompt,
+        width=width,
+        height=height,
+        format="png",
+        size_bytes=len(img_bytes),
+        elapsed_ms=elapsed,
+        base64_data=b64 if b64 else base64.b64encode(img_bytes).decode("ascii"),
+    )
+
+
+def list_image_models() -> list[dict[str, Any]]:
+    logger.debug("Entered into list_image_models")
+    return [
+        {"model": name, "vendor": info["vendor"], "max_size": info["max_size"]}
+        for name, info in IMAGE_MODELS.items()
+    ]