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

elidia/creative/local.py

@@ -0,0 +1,163 @@
+"""Local creative generation — runs models on the user's machine.
+
+Uses diffusers for image generation (SD-turbo, SDXL-lightning) when
+available. Falls back gracefully when dependencies are not installed.
+"""
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_OUTPUT_DIR = Path.home() / ".elidia" / "generated" / "local"
+
+LOCAL_IMAGE_MODELS = {
+    "sd-turbo": {
+        "repo": "stabilityai/sd-turbo",
+        "steps": 4,
+        "guidance": 0.0,
+        "description": "Fast 4-step image generation (512x512)",
+    },
+    "sdxl-lightning-4step": {
+        "repo": "ByteDance/SDXL-Lightning",
+        "steps": 4,
+        "guidance": 0.0,
+        "description": "Fast SDXL variant (1024x1024)",
+    },
+}
+
+
+@dataclass
+class LocalImageResult:
+    file_path: str
+    model: str
+    prompt: str
+    width: int
+    height: int
+    steps: int
+    elapsed_ms: int = 0
+    size_bytes: int = 0
+
+
+def check_local_available() -> dict[str, bool]:
+    logger.debug("Entered into check_local_available")
+    status: dict[str, bool] = {}
+
+    try:
+        import torch  # noqa: F401
+        status["torch"] = True
+    except ImportError:
+        status["torch"] = False
+
+    try:
+        import diffusers  # noqa: F401
+        status["diffusers"] = True
+    except ImportError:
+        status["diffusers"] = False
+
+    status["gpu"] = False
+    if status["torch"]:
+        try:
+            import torch
+            status["gpu"] = torch.cuda.is_available() or (hasattr(torch.backends, "mps") and torch.backends.mps.is_available())
+        except Exception:
+            pass
+
+    status["ready"] = status["torch"] and status["diffusers"]
+    return status
+
+
+async def generate_local_image(
+    prompt: str,
+    model: str = "sd-turbo",
+    width: int = 512,
+    height: int = 512,
+    output_dir: Path | None = None,
+    num_steps: int | None = None,
+) -> LocalImageResult:
+    logger.debug(f"Entered into generate_local_image: model={model}, prompt={prompt[:60]!r}")
+    start = time.monotonic()
+
+    avail = check_local_available()
+    if not avail["ready"]:
+        missing = []
+        if not avail["torch"]:
+            missing.append("torch")
+        if not avail["diffusers"]:
+            missing.append("diffusers")
+        raise RuntimeError(
+            f"Local generation requires: {', '.join(missing)}. "
+            f"Install with: pip install {' '.join(missing)}"
+        )
+
+    model_info = LOCAL_IMAGE_MODELS.get(model)
+    if not model_info:
+        raise RuntimeError(f"Unknown local model: {model}. Available: {list(LOCAL_IMAGE_MODELS.keys())}")
+
+    steps = num_steps or model_info["steps"]
+    guidance = model_info["guidance"]
+
+    save_dir = output_dir or DEFAULT_OUTPUT_DIR
+    save_dir.mkdir(parents=True, exist_ok=True)
+
+    import torch
+    from diffusers import AutoPipelineForText2Image
+
+    device = "cuda" if torch.cuda.is_available() else "mps" if (hasattr(torch.backends, "mps") and torch.backends.mps.is_available()) else "cpu"
+    dtype = torch.float16 if device != "cpu" else torch.float32
+
+    logger.info(f"Loading {model_info['repo']} on {device} ({dtype})")
+    pipe = AutoPipelineForText2Image.from_pretrained(
+        model_info["repo"],
+        torch_dtype=dtype,
+        variant="fp16" if dtype == torch.float16 else None,
+    )
+    pipe = pipe.to(device)
+
+    image = pipe(
+        prompt=prompt,
+        num_inference_steps=steps,
+        guidance_scale=guidance,
+        width=width,
+        height=height,
+    ).images[0]
+
+    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}_local_{safe_prompt}.png"
+    file_path = save_dir / filename
+    image.save(str(file_path))
+
+    size_bytes = file_path.stat().st_size
+    elapsed = int((time.monotonic() - start) * 1000)
+    logger.info(f"Local image generated: {file_path} ({size_bytes} bytes, {elapsed}ms)")
+
+    return LocalImageResult(
+        file_path=str(file_path),
+        model=model,
+        prompt=prompt,
+        width=width,
+        height=height,
+        steps=steps,
+        elapsed_ms=elapsed,
+        size_bytes=size_bytes,
+    )
+
+
+def list_local_models() -> list[dict[str, Any]]:
+    logger.debug("Entered into list_local_models")
+    avail = check_local_available()
+    return [
+        {
+            "model": name,
+            "repo": info["repo"],
+            "description": info["description"],
+            "steps": info["steps"],
+            "available": avail["ready"],
+        }
+        for name, info in LOCAL_IMAGE_MODELS.items()
+    ]

elidia/creative/video.py

@@ -0,0 +1,181 @@
+"""Video generation via AiUtils Developer API.
+
+Supports text-to-video and image-to-video through models like Kling and
+Minimax. Video generation is asynchronous — submit a job, poll for completion.
+"""
+from __future__ import annotations
+
+import asyncio
+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__)
+
+VIDEO_MODELS = {
+    "kling-v2": {"vendor": "kling", "max_duration": 10, "supports_image": True},
+    "kling-v1.6": {"vendor": "kling", "max_duration": 5, "supports_image": True},
+    "minimax-video-01": {"vendor": "minimax", "max_duration": 6, "supports_image": False},
+}
+
+DEFAULT_MODEL = "kling-v2"
+DEFAULT_OUTPUT_DIR = Path.home() / ".elidia" / "generated" / "videos"
+
+
+@dataclass
+class VideoResult:
+    file_path: str
+    model: str
+    prompt: str
+    duration: int
+    format: str = "mp4"
+    size_bytes: int = 0
+    elapsed_ms: int = 0
+    job_id: str = ""
+
+
+async def generate_video(
+    client: AiUtilsClient,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    duration: int = 5,
+    image_path: str | None = None,
+    output_dir: Path | None = None,
+    poll_interval: float = 5.0,
+    max_wait: float = 300.0,
+) -> VideoResult:
+    logger.debug(f"Entered into generate_video: 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 = VIDEO_MODELS.get(model, VIDEO_MODELS[DEFAULT_MODEL])
+    duration = min(duration, model_info["max_duration"])
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "prompt": prompt,
+        "duration": duration,
+    }
+
+    if image_path and model_info["supports_image"]:
+        img_bytes = Path(image_path).read_bytes()
+        payload["image"] = base64.b64encode(img_bytes).decode("ascii")
+
+    headers = {
+        "Authorization": f"Bearer {client._api_key}",
+        "Content-Type": "application/json",
+    }
+
+    async with httpx.AsyncClient(
+        base_url=client._base_url,
+        headers=headers,
+        timeout=httpx.Timeout(30.0, connect=10.0),
+    ) as http:
+        response = await http.post("/videos/generations", json=payload)
+
+        if response.status_code == 401:
+            raise RuntimeError("Invalid API key for video generation")
+        if response.status_code == 402:
+            raise RuntimeError("Insufficient balance for video generation")
+        response.raise_for_status()
+
+        data = response.json()
+        job_id = data.get("id", data.get("job_id", ""))
+
+        if not job_id:
+            video_url = data.get("url", "")
+            if video_url:
+                return await _download_and_save(
+                    video_url, prompt, model, duration, save_dir, start, job_id
+                )
+            raise RuntimeError("No job ID or video URL returned")
+
+        logger.info(f"Video job submitted: {job_id}")
+
+        waited = 0.0
+        while waited < max_wait:
+            await asyncio.sleep(poll_interval)
+            waited += poll_interval
+
+            status_resp = await http.get(f"/videos/generations/{job_id}")
+            if status_resp.status_code >= 400:
+                logger.warning(f"Poll error {status_resp.status_code} for job {job_id}")
+                continue
+
+            status_data = status_resp.json()
+            state = status_data.get("status", "").lower()
+
+            if state in ("completed", "succeeded", "done"):
+                video_url = status_data.get("url", status_data.get("video_url", ""))
+                if not video_url:
+                    results = status_data.get("data", status_data.get("results", []))
+                    if results and isinstance(results, list):
+                        video_url = results[0].get("url", "")
+
+                if video_url:
+                    return await _download_and_save(
+                        video_url, prompt, model, duration, save_dir, start, job_id
+                    )
+                raise RuntimeError(f"Job {job_id} completed but no video URL found")
+
+            elif state in ("failed", "error"):
+                error = status_data.get("error", status_data.get("message", "unknown error"))
+                raise RuntimeError(f"Video generation failed: {error}")
+
+            logger.debug(f"Job {job_id} status: {state}, waited {waited:.0f}s")
+
+        raise RuntimeError(f"Video generation timed out after {max_wait}s (job: {job_id})")
+
+
+async def _download_and_save(
+    url: str,
+    prompt: str,
+    model: str,
+    duration: int,
+    save_dir: Path,
+    start: float,
+    job_id: str,
+) -> VideoResult:
+    logger.debug(f"Entered into _download_and_save: url={url[:80]}")
+    async with httpx.AsyncClient(timeout=60.0) as dl:
+        vid_resp = await dl.get(url)
+        vid_resp.raise_for_status()
+        vid_bytes = vid_resp.content
+
+    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}_{safe_prompt}.mp4"
+    file_path = save_dir / filename
+    file_path.write_bytes(vid_bytes)
+
+    elapsed = int((time.monotonic() - start) * 1000)
+    logger.info(f"Video saved: {file_path} ({len(vid_bytes)} bytes, {elapsed}ms)")
+
+    return VideoResult(
+        file_path=str(file_path),
+        model=model,
+        prompt=prompt,
+        duration=duration,
+        format="mp4",
+        size_bytes=len(vid_bytes),
+        elapsed_ms=elapsed,
+        job_id=job_id,
+    )
+
+
+def list_video_models() -> list[dict[str, Any]]:
+    logger.debug("Entered into list_video_models")
+    return [
+        {"model": name, "vendor": info["vendor"], "max_duration": info["max_duration"],
+         "supports_image": info["supports_image"]}
+        for name, info in VIDEO_MODELS.items()
+    ]

elidia/daemon/manager.py

@@ -0,0 +1,349 @@
+"""Daemon mode — background task manager with watchers, schedules, and webhooks.
+
+Manages long-running background tasks:
+  - File watchers: monitor directories for changes
+  - Scheduled tasks: run at intervals or cron-like expressions
+  - Webhook listener: HTTP endpoint that triggers workflows
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DaemonTask:
+    id: str
+    name: str
+    type: str  # "watcher", "schedule", "webhook"
+    config: dict[str, Any] = field(default_factory=dict)
+    status: str = "stopped"  # "running", "stopped", "error"
+    last_run: float = 0.0
+    run_count: int = 0
+    error: str = ""
+
+
+@dataclass
+class DaemonEvent:
+    kind: str  # "task_start", "task_stop", "task_trigger", "task_error", "status"
+    data: Any = None
+
+
+class DaemonManager:
+    """Manages background daemon tasks."""
+
+    def __init__(self) -> None:
+        logger.debug("Entered into DaemonManager.__init__")
+        self._tasks: dict[str, DaemonTask] = {}
+        self._handles: dict[str, asyncio.Task[None]] = {}
+        self._callbacks: dict[str, Callable[..., Coroutine[Any, Any, None]]] = {}
+        self._running = False
+        self._webhook_server: asyncio.Server | None = None
+
+    async def start(self) -> None:
+        logger.debug("Entered into DaemonManager.start")
+        self._running = True
+        for task_id, task in self._tasks.items():
+            if task.status == "stopped":
+                await self._start_task(task)
+
+    async def stop(self) -> None:
+        logger.debug("Entered into DaemonManager.stop")
+        self._running = False
+        for task_id in list(self._handles.keys()):
+            await self._stop_task(task_id)
+        if self._webhook_server:
+            self._webhook_server.close()
+            await self._webhook_server.wait_closed()
+            self._webhook_server = None
+
+    def add_watcher(
+        self,
+        name: str,
+        path: str,
+        patterns: list[str] | None = None,
+        interval: float = 2.0,
+        callback: Callable[..., Coroutine[Any, Any, None]] | None = None,
+    ) -> str:
+        logger.debug(f"Entered into add_watcher: name={name}, path={path}")
+        task_id = f"watch_{name}_{int(time.time())}"
+        task = DaemonTask(
+            id=task_id,
+            name=name,
+            type="watcher",
+            config={
+                "path": path,
+                "patterns": patterns or ["*"],
+                "interval": interval,
+            },
+        )
+        self._tasks[task_id] = task
+        if callback:
+            self._callbacks[task_id] = callback
+        return task_id
+
+    def add_schedule(
+        self,
+        name: str,
+        interval_seconds: float,
+        command: str = "",
+        callback: Callable[..., Coroutine[Any, Any, None]] | None = None,
+    ) -> str:
+        logger.debug(f"Entered into add_schedule: name={name}, interval={interval_seconds}")
+        task_id = f"sched_{name}_{int(time.time())}"
+        task = DaemonTask(
+            id=task_id,
+            name=name,
+            type="schedule",
+            config={
+                "interval": interval_seconds,
+                "command": command,
+            },
+        )
+        self._tasks[task_id] = task
+        if callback:
+            self._callbacks[task_id] = callback
+        return task_id
+
+    def add_webhook(
+        self,
+        name: str,
+        path: str = "/webhook",
+        port: int = 8765,
+        callback: Callable[..., Coroutine[Any, Any, None]] | None = None,
+    ) -> str:
+        logger.debug(f"Entered into add_webhook: name={name}, path={path}, port={port}")
+        task_id = f"hook_{name}_{int(time.time())}"
+        task = DaemonTask(
+            id=task_id,
+            name=name,
+            type="webhook",
+            config={
+                "path": path,
+                "port": port,
+            },
+        )
+        self._tasks[task_id] = task
+        if callback:
+            self._callbacks[task_id] = callback
+        return task_id
+
+    async def remove_task(self, task_id: str) -> bool:
+        logger.debug(f"Entered into remove_task: id={task_id}")
+        if task_id in self._handles:
+            await self._stop_task(task_id)
+        if task_id in self._tasks:
+            del self._tasks[task_id]
+            self._callbacks.pop(task_id, None)
+            return True
+        return False
+
+    def list_tasks(self) -> list[DaemonTask]:
+        logger.debug("Entered into list_tasks")
+        return list(self._tasks.values())
+
+    def get_status(self) -> dict[str, Any]:
+        logger.debug("Entered into get_status")
+        return {
+            "running": self._running,
+            "task_count": len(self._tasks),
+            "active": sum(1 for t in self._tasks.values() if t.status == "running"),
+            "tasks": [
+                {
+                    "id": t.id,
+                    "name": t.name,
+                    "type": t.type,
+                    "status": t.status,
+                    "run_count": t.run_count,
+                    "last_run": t.last_run,
+                    "error": t.error,
+                }
+                for t in self._tasks.values()
+            ],
+        }
+
+    async def _start_task(self, task: DaemonTask) -> None:
+        logger.debug(f"Entered into _start_task: id={task.id}, type={task.type}")
+        if task.id in self._handles:
+            return
+
+        if task.type == "watcher":
+            self._handles[task.id] = asyncio.create_task(self._run_watcher(task))
+        elif task.type == "schedule":
+            self._handles[task.id] = asyncio.create_task(self._run_schedule(task))
+        elif task.type == "webhook":
+            self._handles[task.id] = asyncio.create_task(self._run_webhook(task))
+
+        task.status = "running"
+
+    async def _stop_task(self, task_id: str) -> None:
+        logger.debug(f"Entered into _stop_task: id={task_id}")
+        handle = self._handles.pop(task_id, None)
+        if handle and not handle.done():
+            handle.cancel()
+            try:
+                await handle
+            except asyncio.CancelledError:
+                pass
+        if task_id in self._tasks:
+            self._tasks[task_id].status = "stopped"
+
+    async def _run_watcher(self, task: DaemonTask) -> None:
+        logger.debug(f"Entered into _run_watcher: id={task.id}")
+        watch_path = Path(task.config["path"])
+        interval = task.config.get("interval", 2.0)
+        patterns = task.config.get("patterns", ["*"])
+
+        file_states: dict[str, float] = {}
+        if watch_path.is_dir():
+            for pattern in patterns:
+                for f in watch_path.rglob(pattern):
+                    if f.is_file():
+                        file_states[str(f)] = f.stat().st_mtime
+
+        try:
+            while self._running:
+                await asyncio.sleep(interval)
+                if not watch_path.exists():
+                    continue
+
+                current: dict[str, float] = {}
+                for pattern in patterns:
+                    for f in watch_path.rglob(pattern):
+                        if f.is_file():
+                            current[str(f)] = f.stat().st_mtime
+
+                changed = [p for p, mt in current.items() if file_states.get(p) != mt]
+                deleted = [p for p in file_states if p not in current]
+
+                if changed or deleted:
+                    task.run_count += 1
+                    task.last_run = time.time()
+                    callback = self._callbacks.get(task.id)
+                    if callback:
+                        try:
+                            await callback(changed=changed, deleted=deleted, task=task)
+                        except Exception as e:
+                            task.error = str(e)
+                            logger.warning(f"Watcher callback error: {e}")
+
+                file_states = current
+
+        except asyncio.CancelledError:
+            pass
+
+    async def _run_schedule(self, task: DaemonTask) -> None:
+        logger.debug(f"Entered into _run_schedule: id={task.id}")
+        interval = task.config.get("interval", 60.0)
+        command = task.config.get("command", "")
+
+        try:
+            while self._running:
+                await asyncio.sleep(interval)
+                task.run_count += 1
+                task.last_run = time.time()
+
+                callback = self._callbacks.get(task.id)
+                if callback:
+                    try:
+                        await callback(task=task)
+                    except Exception as e:
+                        task.error = str(e)
+                        logger.warning(f"Schedule callback error: {e}")
+                elif command:
+                    try:
+                        proc = await asyncio.create_subprocess_shell(
+                            command,
+                            stdout=asyncio.subprocess.PIPE,
+                            stderr=asyncio.subprocess.PIPE,
+                        )
+                        await asyncio.wait_for(proc.communicate(), timeout=30)
+                    except Exception as e:
+                        task.error = str(e)
+                        logger.warning(f"Schedule command error: {e}")
+
+        except asyncio.CancelledError:
+            pass
+
+    async def _run_webhook(self, task: DaemonTask) -> None:
+        logger.debug(f"Entered into _run_webhook: id={task.id}")
+        port = task.config.get("port", 8765)
+        expected_path = task.config.get("path", "/webhook")
+
+        async def handle_request(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+            try:
+                request_line = await asyncio.wait_for(reader.readline(), timeout=10)
+                line = request_line.decode("utf-8", errors="replace").strip()
+                parts = line.split(" ")
+                method = parts[0] if parts else "GET"
+                path = parts[1] if len(parts) > 1 else "/"
+
+                headers: dict[str, str] = {}
+                content_length = 0
+                while True:
+                    header_line = await asyncio.wait_for(reader.readline(), timeout=5)
+                    header = header_line.decode("utf-8", errors="replace").strip()
+                    if not header:
+                        break
+                    if ":" in header:
+                        key, val = header.split(":", 1)
+                        headers[key.strip().lower()] = val.strip()
+                        if key.strip().lower() == "content-length":
+                            content_length = int(val.strip())
+
+                body = b""
+                if content_length > 0:
+                    body = await asyncio.wait_for(reader.read(min(content_length, 65536)), timeout=10)
+
+                if path == expected_path and method == "POST":
+                    task.run_count += 1
+                    task.last_run = time.time()
+
+                    payload: dict[str, Any] = {}
+                    if body:
+                        try:
+                            payload = json.loads(body)
+                        except json.JSONDecodeError:
+                            payload = {"raw": body.decode("utf-8", errors="replace")}
+
+                    callback = self._callbacks.get(task.id)
+                    if callback:
+                        try:
+                            await callback(payload=payload, task=task)
+                        except Exception as e:
+                            task.error = str(e)
+
+                    response = 'HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n{"status": "ok"}'
+                else:
+                    response = 'HTTP/1.1 404 Not Found\r\nContent-Type: application/json\r\n\r\n{"error": "not found"}'
+
+                writer.write(response.encode())
+                await writer.drain()
+            except Exception as e:
+                logger.debug(f"Webhook request error: {e}")
+            finally:
+                writer.close()
+                try:
+                    await writer.wait_closed()
+                except Exception:
+                    pass
+
+        try:
+            self._webhook_server = await asyncio.start_server(handle_request, "127.0.0.1", port)
+            logger.info(f"Webhook listener started on 127.0.0.1:{port}{expected_path}")
+            async with self._webhook_server:
+                await self._webhook_server.serve_forever()
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            task.status = "error"
+            task.error = str(e)
+            logger.warning(f"Webhook server error: {e}")