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

elidia/cli/themes.py

@@ -0,0 +1,214 @@
+"""Configurable themes — dark/light/custom color schemes for the CLI.
+
+Themes define colors for all UI elements: prompts, borders, status,
+code blocks, errors, etc. Users can select a built-in theme or define
+custom themes in ~/.elidia/themes.toml.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+
+from rich.console import Console
+from rich.style import Style
+from rich.theme import Theme
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class ElidiaTheme:
+    name: str
+    description: str = ""
+    primary: str = "cyan"
+    secondary: str = "blue"
+    accent: str = "magenta"
+    success: str = "green"
+    warning: str = "yellow"
+    error: str = "red"
+    dim: str = "dim"
+    border: str = "cyan"
+    prompt_style: str = "bold cyan"
+    assistant_style: str = ""
+    code_style: str = "dim"
+    heading_style: str = "bold"
+    status_style: str = "dim"
+
+
+BUILTIN_THEMES: dict[str, ElidiaTheme] = {
+    "default": ElidiaTheme(
+        name="default",
+        description="Default Elidia theme",
+    ),
+    "dark": ElidiaTheme(
+        name="dark",
+        description="High contrast dark theme",
+        primary="bright_cyan",
+        secondary="bright_blue",
+        accent="bright_magenta",
+        border="bright_cyan",
+        prompt_style="bold bright_cyan",
+    ),
+    "light": ElidiaTheme(
+        name="light",
+        description="Light terminal theme",
+        primary="blue",
+        secondary="dark_blue",
+        accent="dark_magenta",
+        success="dark_green",
+        warning="dark_orange",
+        error="dark_red",
+        border="blue",
+        prompt_style="bold blue",
+    ),
+    "minimal": ElidiaTheme(
+        name="minimal",
+        description="Clean, low-color theme",
+        primary="white",
+        secondary="white",
+        accent="white",
+        success="green",
+        warning="yellow",
+        error="red",
+        border="white",
+        prompt_style="bold",
+        dim="dim white",
+    ),
+    "ocean": ElidiaTheme(
+        name="ocean",
+        description="Cool blue-green palette",
+        primary="deep_sky_blue1",
+        secondary="steel_blue",
+        accent="medium_spring_green",
+        success="spring_green2",
+        warning="gold1",
+        error="indian_red1",
+        border="deep_sky_blue1",
+        prompt_style="bold deep_sky_blue1",
+    ),
+    "sunset": ElidiaTheme(
+        name="sunset",
+        description="Warm orange-red palette",
+        primary="orange1",
+        secondary="dark_orange",
+        accent="hot_pink",
+        success="chartreuse1",
+        warning="gold1",
+        error="red1",
+        border="orange1",
+        prompt_style="bold orange1",
+    ),
+}
+
+
+class ThemeManager:
+    """Manages theme selection and application."""
+
+    def __init__(self, theme_name: str = "default") -> None:
+        logger.debug(f"Entered into ThemeManager.__init__: theme={theme_name}")
+        self._current_name = theme_name
+        self._current = BUILTIN_THEMES.get(theme_name, BUILTIN_THEMES["default"])
+        self._custom_themes: dict[str, ElidiaTheme] = {}
+
+    @property
+    def current(self) -> ElidiaTheme:
+        return self._current
+
+    @property
+    def current_name(self) -> str:
+        return self._current_name
+
+    def set_theme(self, name: str) -> ElidiaTheme | None:
+        logger.debug(f"Entered into set_theme: name={name}")
+        theme = BUILTIN_THEMES.get(name) or self._custom_themes.get(name)
+        if theme:
+            self._current = theme
+            self._current_name = name
+            return theme
+        return None
+
+    def list_themes(self) -> list[dict[str, str]]:
+        logger.debug("Entered into list_themes")
+        result: list[dict[str, str]] = []
+        for name, theme in BUILTIN_THEMES.items():
+            result.append({
+                "name": name,
+                "description": theme.description,
+                "type": "builtin",
+            })
+        for name, theme in self._custom_themes.items():
+            result.append({
+                "name": name,
+                "description": theme.description,
+                "type": "custom",
+            })
+        return result
+
+    def load_custom_themes(self, path: Path) -> int:
+        logger.debug(f"Entered into load_custom_themes: path={path}")
+        if not path.exists():
+            return 0
+
+        try:
+            import tomllib
+        except ImportError:
+            try:
+                import tomli as tomllib
+            except ImportError:
+                logger.warning("tomllib/tomli not available for custom theme loading")
+                return 0
+
+        try:
+            data = tomllib.loads(path.read_text(encoding="utf-8"))
+        except Exception as e:
+            logger.warning(f"Failed to parse themes file: {e}")
+            return 0
+
+        count = 0
+        for name, raw in data.items():
+            if not isinstance(raw, dict):
+                continue
+            theme = ElidiaTheme(
+                name=name,
+                description=raw.get("description", ""),
+                primary=raw.get("primary", "cyan"),
+                secondary=raw.get("secondary", "blue"),
+                accent=raw.get("accent", "magenta"),
+                success=raw.get("success", "green"),
+                warning=raw.get("warning", "yellow"),
+                error=raw.get("error", "red"),
+                dim=raw.get("dim", "dim"),
+                border=raw.get("border", "cyan"),
+                prompt_style=raw.get("prompt_style", "bold cyan"),
+                assistant_style=raw.get("assistant_style", ""),
+                code_style=raw.get("code_style", "dim"),
+                heading_style=raw.get("heading_style", "bold"),
+                status_style=raw.get("status_style", "dim"),
+            )
+            self._custom_themes[name] = theme
+            count += 1
+
+        return count
+
+    def to_rich_theme(self) -> Theme:
+        logger.debug("Entered into to_rich_theme")
+        t = self._current
+        return Theme({
+            "elidia.primary": Style.parse(t.primary),
+            "elidia.secondary": Style.parse(t.secondary),
+            "elidia.accent": Style.parse(t.accent),
+            "elidia.success": Style.parse(t.success),
+            "elidia.warning": Style.parse(t.warning),
+            "elidia.error": Style.parse(t.error),
+            "elidia.dim": Style.parse(t.dim),
+            "elidia.border": Style.parse(t.border),
+            "elidia.prompt": Style.parse(t.prompt_style),
+            "elidia.heading": Style.parse(t.heading_style),
+            "elidia.status": Style.parse(t.status_style),
+            "elidia.code": Style.parse(t.code_style),
+        })
+
+    def create_console(self) -> Console:
+        logger.debug("Entered into create_console")
+        return Console(theme=self.to_rich_theme())

elidia/config/defaults.py

@@ -0,0 +1,5 @@
+from elidia.config.settings import ElidiaConfig
+
+VERSION = "0.1.0"
+
+DEFAULT_CONFIG = ElidiaConfig()

elidia/config/rules.py

@@ -0,0 +1,48 @@
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+RULES_FILENAMES = [".elidia/rules.md", ".elidia/rules.txt", ".elidia/RULES.md"]
+
+
+def load_project_rules(project_root: Path | None = None) -> str | None:
+    logger.debug(f"Entered into load_project_rules: root={project_root}")
+
+    if project_root is None:
+        project_root = _find_project_root()
+        if project_root is None:
+            return None
+
+    for filename in RULES_FILENAMES:
+        rules_path = project_root / filename
+        if rules_path.exists() and rules_path.is_file():
+            try:
+                content = rules_path.read_text(encoding="utf-8")
+                if content.strip():
+                    logger.info(f"Loaded project rules from {rules_path}")
+                    return content.strip()
+            except Exception as e:
+                logger.warning(f"Could not read {rules_path}: {e}")
+
+    return None
+
+
+def _find_project_root() -> Path | None:
+    cwd = Path.cwd()
+    for parent in [cwd] + list(cwd.parents):
+        if (parent / ".git").exists():
+            return parent
+        if (parent / ".elidia").exists():
+            return parent
+    return cwd
+
+
+def format_rules_for_system_prompt(rules: str) -> str:
+    logger.debug(f"Entered into format_rules_for_system_prompt: len={len(rules)}")
+    return (
+        "\n\n--- Project Rules (from .elidia/rules.md) ---\n"
+        "The following rules are set by the project owner. Follow them.\n\n"
+        f"{rules}\n"
+        "\n--- End Project Rules ---\n"
+    )

elidia/config/settings.py

@@ -0,0 +1,217 @@
+import dataclasses
+import logging
+import os
+import tomllib
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+ELIDIA_HOME = Path(os.environ.get("ELIDIA_HOME", Path.home() / ".elidia"))
+PROJECT_DIR = Path(".elidia")
+
+_HOME_SUBDIRS = ("cache", "memory", "rag", "skills", "workflows", "prompts", "plugins")
+
+
+@dataclasses.dataclass
+class ApiConfig:
+    key: str = ""
+    base_url: str = "https://developer.aiutils.io/v1"
+    timeout_seconds: int = 120
+    max_retries: int = 3
+
+
+@dataclasses.dataclass
+class ModelConfig:
+    default: str = "auto"
+    reasoning: str = "deepseek-reasoner"
+    code: str = "claude-sonnet-5"
+    creative: str = "gpt-5"
+    cheap: str = "deepseek-chat"
+    vision: str = "gpt-5-vision"
+    embedding: str = "local"
+
+
+@dataclasses.dataclass
+class LocalModelConfig:
+    enabled: bool = True
+    ollama_url: str = "http://localhost:11434"
+    prefer_local_for: list[str] = dataclasses.field(default_factory=lambda: ["simple-chat", "summarize"])
+    auto_fallback: bool = True
+
+
+@dataclasses.dataclass
+class MemoryConfig:
+    enabled: bool = True
+    auto_save: bool = True
+    cloud_sync: bool = False
+    max_entries: int = 50000
+    compaction_after_messages: int = 100
+    similarity_threshold: float = 0.30
+
+
+@dataclasses.dataclass
+class RagConfig:
+    enabled: bool = True
+    auto_index: bool = True
+    watch_extensions: list[str] = dataclasses.field(
+        default_factory=lambda: ["md", "txt", "pdf", "py", "ts", "js", "rs", "go", "json", "yaml", "toml"]
+    )
+    chunk_size: int = 512
+    chunk_overlap: int = 64
+    portal_bridge: bool = False
+
+
+@dataclasses.dataclass
+class PermissionConfig:
+    auto_approve_reads: bool = True
+    auto_approve_writes: bool = False
+    auto_approve_commands: bool = False
+    auto_approve_network: bool = True
+    progressive_trust: bool = True
+    trust_threshold: int = 20
+
+
+@dataclasses.dataclass
+class BudgetConfig:
+    session_limit: int = 0
+    monthly_limit: int = 0
+    warn_at_percentage: int = 80
+    default_thinking_level: str = "auto"
+
+
+@dataclasses.dataclass
+class UiConfig:
+    theme: str = "auto"
+    markdown: bool = True
+    image_display: bool = True
+    syntax_highlighting: bool = True
+    max_output_lines: int = 500
+    keybindings: str = "emacs"
+
+
+@dataclasses.dataclass
+class ElidiaConfig:
+    api: ApiConfig = dataclasses.field(default_factory=ApiConfig)
+    models: ModelConfig = dataclasses.field(default_factory=ModelConfig)
+    local_models: LocalModelConfig = dataclasses.field(default_factory=LocalModelConfig)
+    memory: MemoryConfig = dataclasses.field(default_factory=MemoryConfig)
+    rag: RagConfig = dataclasses.field(default_factory=RagConfig)
+    permissions: PermissionConfig = dataclasses.field(default_factory=PermissionConfig)
+    budget: BudgetConfig = dataclasses.field(default_factory=BudgetConfig)
+    ui: UiConfig = dataclasses.field(default_factory=UiConfig)
+
+
+# env var -> (dataclass field on ElidiaConfig, field on the nested section)
+_ENV_OVERRIDES: dict[str, tuple[str, str]] = {
+    "AIUTILS_API_KEY": ("api", "key"),
+    "ELIDIA_API_BASE_URL": ("api", "base_url"),
+    "ELIDIA_API_TIMEOUT_SECONDS": ("api", "timeout_seconds"),
+    "ELIDIA_API_MAX_RETRIES": ("api", "max_retries"),
+    "ELIDIA_MODEL": ("models", "default"),
+    "ELIDIA_MODEL_REASONING": ("models", "reasoning"),
+    "ELIDIA_MODEL_CODE": ("models", "code"),
+    "ELIDIA_MODEL_CREATIVE": ("models", "creative"),
+    "ELIDIA_MODEL_CHEAP": ("models", "cheap"),
+    "ELIDIA_MODEL_VISION": ("models", "vision"),
+    "ELIDIA_OLLAMA_URL": ("local_models", "ollama_url"),
+    "ELIDIA_LOCAL_MODELS_ENABLED": ("local_models", "enabled"),
+    "ELIDIA_THEME": ("ui", "theme"),
+    "ELIDIA_SESSION_BUDGET": ("budget", "session_limit"),
+    "ELIDIA_MONTHLY_BUDGET": ("budget", "monthly_limit"),
+}
+
+
+def ensure_elidia_home() -> None:
+    logger.debug(f"Entered into ensure_elidia_home: home={ELIDIA_HOME}")
+    ELIDIA_HOME.mkdir(parents=True, exist_ok=True)
+    for subdir in _HOME_SUBDIRS:
+        (ELIDIA_HOME / subdir).mkdir(parents=True, exist_ok=True)
+
+
+def _merge_toml_into_dataclass(data: dict, dc: object) -> object:
+    logger.debug(f"Entered into _merge_toml_into_dataclass: keys={list(data.keys())}")
+    for field in dataclasses.fields(dc):
+        if field.name not in data:
+            continue
+        value = data[field.name]
+        current = getattr(dc, field.name)
+        if dataclasses.is_dataclass(current) and isinstance(value, dict):
+            _merge_toml_into_dataclass(value, current)
+        else:
+            setattr(dc, field.name, value)
+    return dc
+
+
+def _load_toml_file(path: Path) -> dict:
+    logger.debug(f"Entered into _load_toml_file: path={path}")
+    try:
+        with path.open("rb") as f:
+            return tomllib.load(f)
+    except (tomllib.TOMLDecodeError, OSError) as exc:
+        logger.warning(f"Entered into _load_toml_file: failed to parse {path}: {exc}")
+        return {}
+
+
+def _apply_env_overrides(config: ElidiaConfig) -> None:
+    logger.debug("Entered into _apply_env_overrides: applying environment variable overrides")
+    for env_var, (section_name, field_name) in _ENV_OVERRIDES.items():
+        raw_value = os.environ.get(env_var)
+        if raw_value is None:
+            continue
+        section = getattr(config, section_name)
+        current_value = getattr(section, field_name)
+        if isinstance(current_value, bool):
+            coerced_value: object = raw_value.strip().lower() in {"1", "true", "yes", "on"}
+        elif isinstance(current_value, int):
+            coerced_value = int(raw_value)
+        elif isinstance(current_value, float):
+            coerced_value = float(raw_value)
+        else:
+            coerced_value = raw_value
+        setattr(section, field_name, coerced_value)
+
+
+def load_config() -> ElidiaConfig:
+    logger.debug("Entered into load_config: loading configuration")
+    ensure_elidia_home()
+    config = ElidiaConfig()
+
+    user_config_path = ELIDIA_HOME / "config.toml"
+    if user_config_path.exists():
+        _merge_toml_into_dataclass(_load_toml_file(user_config_path), config)
+
+    project_config_path = PROJECT_DIR / "project.toml"
+    if project_config_path.exists():
+        _merge_toml_into_dataclass(_load_toml_file(project_config_path), config)
+
+    _apply_env_overrides(config)
+    return config
+
+
+def _toml_value(value: object) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        return repr(value)
+    if isinstance(value, str):
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    if isinstance(value, list):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    raise TypeError(f"Unsupported TOML value type: {type(value)!r}")
+
+
+def save_config(config: ElidiaConfig, path: Path) -> None:
+    logger.debug(f"Entered into save_config: path={path}")
+    lines: list[str] = []
+    for section_field in dataclasses.fields(config):
+        section = getattr(config, section_field.name)
+        lines.append(f"[{section_field.name}]")
+        for value_field in dataclasses.fields(section):
+            value = getattr(section, value_field.name)
+            lines.append(f"{value_field.name} = {_toml_value(value)}")
+        lines.append("")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines).rstrip() + "\n", encoding="utf-8")

elidia/creative/__init__.py

@@ -0,0 +1 @@
+"""Creative generation — image, video, audio via AiUtils API and local models."""