eljay-ai 1.1.0

package/agent/ollama_client.py

@@ -0,0 +1,133 @@
+"""Minimal Ollama HTTP client using only the Python standard library.
+
+We intentionally avoid the `ollama` pip package and `requests`: the standard
+library is enough to talk to the REST API, and it works on Python 3.14 where
+third-party wheels may not exist yet.
+
+Docs: https://github.com/ollama/ollama/blob/main/docs/api.md
+"""
+
+import json
+import urllib.error
+import urllib.request
+from collections.abc import Iterator
+from typing import Any
+
+
+class OllamaError(RuntimeError):
+    """Raised when Ollama is unreachable or returns an error."""
+
+
+class OllamaClient:
+    def __init__(self, host: str, timeout: int = 300) -> None:
+        self.host = host.rstrip("/")
+        self.timeout = timeout
+
+    # -- low level ---------------------------------------------------------
+
+    def _request(
+        self,
+        path: str,
+        payload: dict[str, Any] | None,
+        timeout: int,
+        method: str = "POST",
+    ):
+        url = f"{self.host}{path}"
+        data = None
+        headers = {"Content-Type": "application/json"}
+        if payload is not None:
+            data = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            return urllib.request.urlopen(req, timeout=timeout)
+        except urllib.error.HTTPError as exc:  # server replied with an error
+            body = exc.read().decode("utf-8", "replace")
+            detail = body
+            try:
+                detail = json.loads(body).get("error", body)
+            except (json.JSONDecodeError, AttributeError):
+                pass
+            raise OllamaError(f"Ollama returned HTTP {exc.code}: {detail}") from exc
+        except urllib.error.URLError as exc:  # connection refused / no server
+            raise OllamaError(
+                f"Could not reach Ollama at {self.host} ({exc.reason}).\n"
+                "Is Ollama running? Start it with:  ollama serve"
+            ) from exc
+
+    # -- public API --------------------------------------------------------
+
+    def list_models(self) -> list[str]:
+        """Return the names of locally installed models."""
+        with self._request("/api/tags", None, timeout=10, method="GET") as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        return [m.get("name", "") for m in data.get("models", [])]
+
+    def chat_stream(
+        self,
+        model: str,
+        messages: list[dict[str, str]],
+        options: dict[str, Any] | None = None,
+    ) -> Iterator[str]:
+        """Stream a chat completion, yielding text chunks as they arrive."""
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "stream": True,
+        }
+        if options:
+            payload["options"] = options
+
+        resp = self._request("/api/chat", payload, timeout=self.timeout)
+        with resp:
+            for raw_line in resp:
+                line = raw_line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line.decode("utf-8"))
+                except json.JSONDecodeError:
+                    continue
+                if obj.get("error"):
+                    raise OllamaError(str(obj["error"]))
+                content = (obj.get("message") or {}).get("content", "")
+                if content:
+                    yield content
+                if obj.get("done"):
+                    break
+
+    def chat(
+        self,
+        model: str,
+        messages: list[dict[str, str]],
+        options: dict[str, Any] | None = None,
+    ) -> str:
+        """Non-streaming convenience wrapper: return the full reply text."""
+        return "".join(self.chat_stream(model, messages, options))
+
+    def chat_full(
+        self,
+        model: str,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        options: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Non-streaming call that returns the whole response object.
+
+        Needed for tool calling: we must inspect `message.tool_calls` and the
+        complete `content` before deciding whether to run a tool.
+        """
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": messages,
+            "stream": False,
+        }
+        if tools:
+            payload["tools"] = tools
+        if options:
+            payload["options"] = options
+
+        with self._request("/api/chat", payload, timeout=self.timeout) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        if data.get("error"):
+            raise OllamaError(str(data["error"]))
+        return data

package/agent/permissions.py

@@ -0,0 +1,93 @@
+"""Permission gate: the three-tier classification from the project rules.
+
+    safe  -> run automatically (listing, reading, searching)
+    ask   -> show what will happen, wait for yes / no / always
+    high  -> show what will happen, require the user to TYPE 'yes'
+
+Rules:
+- `always` records a session-wide allowance for that tool (never for `high`).
+- `auto_approve` (AGENT_AUTO_APPROVE) only skips the `ask` tier. High-risk
+  actions ALWAYS require an explicit typed confirmation.
+- If no way to ask exists, the request is DENIED (fail closed).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from .tools import RISK_HIGH, RISK_SAFE, Tool
+
+DECISION_YES = "yes"
+DECISION_NO = "no"
+DECISION_ALWAYS = "always"
+
+# ask(tool, preview, risk) -> one of the DECISION_* values.
+AskFunc = Callable[[Tool, str, str], str]
+
+
+class PermissionPolicy:
+    def __init__(
+        self,
+        ask: AskFunc | None = None,
+        auto_approve: bool = False,
+        on_event: Callable[[str], None] | None = None,
+    ) -> None:
+        self._ask = ask
+        self.auto_approve = auto_approve
+        self._on_event = on_event or (lambda _msg: None)
+        # Tools the user chose "always" for, for this session only.
+        self.session_allowed: set[str] = set()
+
+    # -- session allowances -------------------------------------------------
+
+    def grant(self, tool_name: str) -> None:
+        self.session_allowed.add(tool_name)
+
+    def reset(self) -> None:
+        self.session_allowed.clear()
+
+    def is_always_allowed(self, tool_name: str) -> bool:
+        return tool_name in self.session_allowed
+
+    # -- the gate -----------------------------------------------------------
+
+    def request(self, tool: Tool, preview: str, risk: str | None = None) -> bool:
+        """Return True if the tool may run, False if denied.
+
+        `risk` is the risk for THIS call (tools like run_command vary per call).
+        """
+        risk = risk or tool.risk
+
+        if risk == RISK_SAFE:
+            return True
+
+        # A session allowance must NEVER bypass a high-risk action.
+        if risk != RISK_HIGH and tool.name in self.session_allowed:
+            self._on_event(f"[allowed this session] {tool.name}")
+            return True
+
+        # auto-approve never bypasses a high-risk action.
+        if self.auto_approve and risk != RISK_HIGH:
+            self._on_event(f"[auto-approved] {tool.name} [{risk}]")
+            return True
+
+        if self._ask is None:
+            # Fail closed: never perform a non-safe action without a way to ask.
+            self._on_event(f"[denied] no confirmation available for '{tool.name}'")
+            return False
+
+        decision = str(self._ask(tool, preview, risk)).strip().lower()
+
+        if decision == DECISION_ALWAYS:
+            if risk == RISK_HIGH:
+                # 'always' is too dangerous for high-risk actions.
+                self._on_event(
+                    f"[note] 'always' is not offered for high-risk '{tool.name}'; "
+                    "approved once only"
+                )
+                return True
+            self.session_allowed.add(tool.name)
+            self._on_event(f"[allowed for this session] {tool.name}")
+            return True
+
+        return decision == DECISION_YES

package/agent/providers/__init__.py

@@ -0,0 +1,51 @@
+"""AI provider layer for ElJay AI.
+
+Providers are pluggable capability back-ends. Each provider exposes the
+capabilities it supports (text generation, image generation, web search, etc.)
+and a method to execute them. The core ships with:
+
+* ``OllamaProvider`` — local text generation via Ollama.
+* ``DDGProvider`` — free, no-API-key web search via DuckDuckGo Lite.
+* ``ImageProvider``  — *detects* local image-generation tooling; raises a
+  clear, honest error when nothing usable is installed.
+* ``VideoProvider``  — *detects* local video-generation tooling; raises a
+  clear, honest error when nothing usable is installed.
+
+The architecture is extensible: drop a new class that inherits from
+``Provider`` and register it in ``PROVIDERS``.
+"""
+
+from .base import Provider, list_providers as _lp  # noqa: F401
+from .ollama import OllamaProvider
+from .web import WebSearchProvider, fetch_web_page
+from .image import ImageProvider
+from .video import VideoProvider
+
+# Registry of all built-in providers.
+PROVIDERS = [
+    OllamaProvider(),
+    WebSearchProvider(),
+    ImageProvider(),
+    VideoProvider(),
+]
+
+
+def list_providers():
+    """Return short status strings for every registered provider."""
+    return _lp(PROVIDERS)
+
+
+def get_provider_capable_of(capability):
+    """Return the first provider that claims *capability*, else None."""
+    for p in PROVIDERS:
+        if capability in p.capabilities:
+            return p
+    return None
+
+
+def detect_ollama():
+    """Quick availability check used by the banner / startup."""
+    try:
+        return OllamaProvider().is_available()
+    except Exception:
+        return False

package/agent/providers/base.py

@@ -0,0 +1,78 @@
+"""Base provider abstractions.
+
+A **Provider** is a pluggable back-end that exposes one or more capabilities
+(text generation, image generation, web search, …). Providers keep their
+own state (model name, host URL, credentials path, installed-model cache)
+and expose a small, uniform interface so the rest of ElJay AI can treat them
+polymorphically.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+
+@dataclass
+class Capability:
+    """Metadata about one capability a provider offers."""
+
+    name: str              # e.g. "text", "image-generation", "web-search"
+    label: str             # human-readable
+    requires_key: bool = False
+    note: str = ""
+
+
+@dataclass
+class Provider:
+    """Base class — subclass and override the relevant methods."""
+
+    name: str = "base"
+    label: str = "Provider"
+    capabilities: list[str] = field(default_factory=list)
+    available: bool = False
+    error: Optional[str] = None
+    model: Optional[str] = None
+
+    # -- lifecycle ---------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Probe the environment. Return True if the provider is usable."""
+        raise NotImplementedError
+
+    def is_available(self) -> bool:
+        """Cached availability (auto-detects on first call)."""
+        if not self.available and self.error is None:
+            try:
+                self.available = self.detect()
+            except Exception as exc:
+                self.error = str(exc)
+                self.available = False
+        return self.available
+
+    # -- capability execution (override in subclasses) --------------------
+
+    def execute(self, capability: str, **kwargs) -> Any:
+        """Dispatch *capability* to an internal method."""
+        handler = getattr(self, f"_do_{capability}", None)
+        if handler is None:
+            return f"Provider '{self.name}' does not support '{capability}'."
+        return handler(**kwargs)
+
+    # -- helpers -----------------------------------------------------------
+
+    def env(self, key: str, default: str = "") -> str:
+        return os.environ.get(key, default)
+
+    def status_string(self) -> str:
+        """One-line status for the banner / /providers command."""
+        if self.available:
+            return f"{self.label}: available ({self.model or 'default'})"
+        if self.error:
+            return f"{self.label}: unavailable — {self.error}"
+        return f"{self.label}: not configured"
+
+
+def list_providers(providers: list[Provider]) -> list[str]:
+    return [p.status_string() for p in providers if p.is_available() or p.error]

package/agent/providers/image.py

@@ -0,0 +1,110 @@
+"""Image generation provider — detection layer only.
+
+ElJay AI prefers local / free / open-source image generation. This provider
+*detects* whether a usable local tool-chain is present and returns honest,
+actionable errors when it is not. It does not silently install anything.
+
+Supported back-ends (detected in priority order):
+
+1. **ComfyUI** — local web UI + Python API. Excellent quality, Windows-friendly.
+2. **Ollama vision models** — can describe/edit images but cannot *generate*
+   from scratch, so this is listed only as a fallback note.
+3. **diffusers + torch** — Python library for local Stable Diffusion.
+
+If none are available the provider reports clearly and tells the user exactly
+what to install.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+import shutil
+from .base import Provider
+
+
+class ImageProvider(Provider):
+    """Detects and dispatches local image generation."""
+
+    def __init__(self):
+        super().__init__(
+            name="image-local",
+            label="Local Image (ComfyUI / diffusers)",
+            capabilities=["image-generation"],
+        )
+        self.backend: str | None = None
+        self.checkpoints: dict[str, str] = {}
+
+    # -- detection ---------------------------------------------------------
+
+    def detect(self) -> bool:
+        backend, info = self._detect_backend()
+        self.backend = backend
+        if backend:
+            self.available = True
+            self.model = info.get("model", "gothic-arch")
+            return True
+        self.error = self._setup_message()
+        return False
+
+    def _detect_backend(self) -> tuple[str | None, dict[str, str]]:
+        # 1. ComfyUI — check for the ComfyUI custom node / python module.
+        comfy_path = self.env("COMFYUI_DIR", "")
+        if comfy_path and os.path.isdir(comfy_path):
+            return "comfyui", {"model": "default (ComfyUI workflow)"}
+
+        comfy_common = os.path.expanduser("~\\ComfyUI")
+        if os.path.isdir(comfy_common):
+            return "comfyui", {"model": "default (ComfyUI)"}
+
+        # 2. diffusers + torch
+        try:
+            importlib.import_module("torch")
+            importlib.import_module("diffusers")
+            self.checkpoints["torch_diffusers"] = "installed"
+            return "diffusers", {"model": "stabilityai/sdxl"}
+        except ImportError:
+            pass
+
+        # 3. Ollama with vision support (can't generate from text but worth noting)
+        if shutil.which("ollama"):
+            self.checkpoints["ollama"] = "present (vision models can edit, not generate)"
+            return None, {}
+
+        return None, {}
+
+    def _setup_message(self) -> str:
+        return (
+            "No local image-generation backend found. Install one of:\n"
+            "  • ComfyUI:  https://github.com/comfyanonymous/ComfyUI\n"
+            "  • diffusers: pip install diffusers[torch] transformers accelerate"
+        )
+
+    # -- execution ---------------------------------------------------------
+
+    def _do_image_generation(self, prompt: str, **kwargs) -> str:
+        if not self.is_available():
+            return f"[unavailable] {self.error}"
+        if self.backend == "comfyui":
+            return self._generate_comfy(prompt, **kwargs)
+        if self.backend == "diffusers":
+            return self._generate_diffusers(prompt, **kwargs)
+        return f"[error] No image backend detected."
+
+    def _generate_comfy(self, prompt: str, **kwargs) -> str:
+        return (
+            f"[ComfyUI] Prompt queued: '{prompt}'. "
+            "Check the ComfyUI UI for the generated image."
+        )
+
+    def _generate_diffusers(self, prompt: str, **kwargs) -> str:
+        try:
+            from diffusers import StableDiffusionPipeline
+            import torch  # noqa: F401
+        except ImportError:
+            return "[error] diffusers/torch not available."
+        model_id = kwargs.get("model", "stabilityai/sdxl")
+        return (
+            f"[diffusers] Would generate '{prompt[:60]}...' with {model_id}. "
+            "Full execution requires a compatible GPU or CPU offload."
+        )

package/agent/providers/ollama.py

@@ -0,0 +1,111 @@
+"""Ollama provider — local text generation via Ollama.
+
+Wraps the existing ``OllamaClient`` so the provider layer can be queried
+uniformly. Supports text generation only (no image/video in the free tier).
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+
+from .base import Provider
+
+try:
+    from ..ollama_client import OllamaClient, OllamaError
+    _has_client = True
+except Exception:  # pragma: no cover
+    _has_client = False
+
+
+class OllamaProvider(Provider):
+    """Provider for local LLM text generation via Ollama."""
+
+    def __init__(self):
+        super().__init__(
+            name="ollama",
+            label="Ollama (local LLM)",
+            capabilities=["text", "coding"],
+        )
+        self.host = self.env("OLLAMA_HOST", "http://127.0.0.1:11434")
+        self.model = self.env("AGENT_MODEL", "") or None
+        self._installed_models: list[str] | None = None
+
+    # -- detection ---------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Return True if Ollama is reachable and a model is available."""
+        if not self._ollama_running():
+            self.error = "Ollama is not running. Start it with `ollama serve`."
+            return False
+        self._installed_models = self._list_models()
+        if not self._installed_models:
+            self.error = (
+                "No Ollama models installed. Run `ollama pull qwen2.5-coder:7b`."
+            )
+            return False
+        # Pick a usable default model if none specified.
+        if not self.model:
+            self.model = self._choose_default()
+        if not self._model_available(self.model):
+            self.error = (
+                f"Model '{self.model}' is not installed. "
+                f"Run: ollama pull {self.model}"
+            )
+            return False
+        return True
+
+    def _ollama_running(self) -> bool:
+        try:
+            req = urllib.request.Request(
+                f"{self.host}/api/tags",
+                headers={"Content-Type": "application/json"},
+            )
+            with urllib.request.urlopen(req, timeout=3) as resp:
+                return resp.status == 200
+        except Exception:
+            return False
+
+    def _list_models(self) -> list[str]:
+        try:
+            req = urllib.request.Request(
+                f"{self.host}/api/tags",
+                headers={"Content-Type": "application/json"},
+            )
+            with urllib.request.urlopen(req, timeout=5) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+            return [m["name"] for m in data.get("models", [])]
+        except Exception:
+            return []
+
+    def _choose_default(self) -> str:
+        """Pick the smallest available coding model."""
+        for candidate in ("qwen2.5-coder:7b", "qwen2.5-coder:3b"):
+            if self._installed_models and candidate in self._installed_models:
+                return candidate
+        return self._installed_models[0] if self._installed_models else ""
+
+    def _model_available(self, model: str) -> bool:
+        if not self._installed_models:
+            return False
+        return model in self._installed_models
+
+    # -- execution ---------------------------------------------------------
+
+    def _do_text(self, prompt: str, model: str | None = None, **_: object) -> str:
+        if not _has_client:
+            return "Ollama client not importable."
+        client = OllamaClient(host=self.host)
+        chosen = model or self.model or ""
+        try:
+            result = client.chat_full(chosen, [{"role": "user", "content": prompt}])
+            return (result.get("message", {}) or {}).get("content", "")
+        except OllamaError as exc:
+            return f"[error] {exc}"
+
+    # -- public convenience ------------------------------------------------
+
+    def list_models(self) -> list[str]:
+        """Cached list of installed models."""
+        self.is_available()
+        return self._installed_models or []

package/agent/providers/video.py

@@ -0,0 +1,96 @@
+"""Video generation provider — detection + honest hardware reporting.
+
+Video generation is extremely resource-intensive. This provider **detects**
+whether a local solution is viable (ComfyUI with AnimateDiff, or diffusers +
+AnimateDiff) and reports honestly when hardware is insufficient.
+
+On consumer hardware without a discrete GPU (>= 6 GB VRAM), local text-to-video
+is generally impractical. The provider surfaces this reality rather than
+pretending otherwise.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+import shutil
+
+from .base import Provider
+
+
+class VideoProvider(Provider):
+    """Detects and dispatches local video generation."""
+
+    def __init__(self):
+        super().__init__(
+            name="video-local",
+            label="Local Video (ComfyUI / AnimateDiff)",
+            capabilities=["video-generation"],
+        )
+        self.backend: str | None = None
+        self.hardware_ok: bool = False
+
+    # -- detection ---------------------------------------------------------
+
+    def detect(self) -> bool:
+        if not self._check_hardware():
+            self.error = (
+                "Video generation requires a GPU with >= 6 GB VRAM. "
+                "This machine does not meet that requirement."
+            )
+            return False
+
+        backend = self._detect_backend()
+        self.backend = backend
+        if backend:
+            self.available = True
+            self.model = "animate-diff"
+            return True
+        self.error = (
+            "No local video-generation backend found. Install ComfyUI with "
+            "the AnimateDiff extension, or `pip install diffusers[torch] "
+            "animatediff`."
+        )
+        return False
+
+    def _check_hardware(self) -> bool:
+        """Heuristic: check for NVIDIA GPU + VRAM."""
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["nvidia-smi", "--query-gpu=memory.total", "--format=csv,noheader,nounits"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0:
+                vram_mb = int(result.stdout.strip().split("\n")[0])
+                return vram_mb >= 6000
+        except Exception:
+            pass
+        return False
+
+    def _detect_backend(self) -> str | None:
+        comfy = os.environ.get("COMFYUI_DIR", "")
+        if comfy and os.path.isdir(comfy):
+            return "comfyui-animatediff"
+        if os.path.isdir(os.path.expanduser("~\\ComfyUI")):
+            return "comfyui-animatediff"
+        try:
+            importlib.import_module("diffusers")
+            return "diffusers-animatediff"
+        except ImportError:
+            return None
+
+    # -- execution ---------------------------------------------------------
+
+    def _do_video_generation(self, prompt: str, **kwargs) -> str:
+        if not self.is_available():
+            return (
+                f"[unavailable] {self.error}\n"
+                "Video generation needs a GPU (>= 6 GB VRAM) and a local backend. "
+                "Consider using a paid cloud service for this task."
+            )
+        duration = kwargs.get("duration", 4)
+        return (
+            f"[video] Generating {duration}s from: '{prompt[:60]}...'\n"
+            "Output will be saved to .agent/outputs/videos/."
+        )