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

elidia/cli/commands.py

@@ -0,0 +1,122 @@
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SlashCommand:
+    name: str
+    description: str
+    usage: str = ""
+    handler: Callable[..., Any] | None = None
+    category: str = "general"
+
+
+class CommandRegistry:
+    """Registry of slash commands available in the REPL."""
+
+    def __init__(self) -> None:
+        logger.debug("Entered into CommandRegistry.__init__")
+        self._commands: dict[str, SlashCommand] = {}
+
+    def register(self, cmd: SlashCommand) -> None:
+        logger.debug(f"Entered into register: name={cmd.name}")
+        self._commands[cmd.name] = cmd
+
+    def get(self, name: str) -> SlashCommand | None:
+        logger.debug(f"Entered into get: name={name}")
+        clean = name.lstrip("/").lower()
+        return self._commands.get(clean)
+
+    def list_commands(self) -> list[SlashCommand]:
+        logger.debug("Entered into list_commands")
+        return sorted(self._commands.values(), key=lambda c: c.name)
+
+    def list_by_category(self) -> dict[str, list[SlashCommand]]:
+        logger.debug("Entered into list_by_category")
+        cats: dict[str, list[SlashCommand]] = {}
+        for cmd in self._commands.values():
+            cats.setdefault(cmd.category, []).append(cmd)
+        for v in cats.values():
+            v.sort(key=lambda c: c.name)
+        return cats
+
+
+def build_default_commands() -> CommandRegistry:
+    logger.debug("Entered into build_default_commands")
+    registry = CommandRegistry()
+
+    registry.register(SlashCommand(
+        name="help", description="Show available commands",
+        usage="/help [command]", category="general",
+    ))
+    registry.register(SlashCommand(
+        name="model", description="Switch or show current model",
+        usage="/model <name|auto>", category="general",
+    ))
+    registry.register(SlashCommand(
+        name="mode", description="Switch conversation mode",
+        usage="/mode <chat|code|research|think|create>", category="general",
+    ))
+    registry.register(SlashCommand(
+        name="cost", description="Show session token usage and cost",
+        usage="/cost", category="general",
+    ))
+    registry.register(SlashCommand(
+        name="new", description="Start a new conversation session",
+        usage="/new", category="session",
+    ))
+    registry.register(SlashCommand(
+        name="sessions", description="List recent sessions",
+        usage="/sessions", category="session",
+    ))
+    registry.register(SlashCommand(
+        name="clear", description="Clear current conversation history",
+        usage="/clear", category="session",
+    ))
+    registry.register(SlashCommand(
+        name="tools", description="List available tools",
+        usage="/tools [category]", category="tools",
+    ))
+    registry.register(SlashCommand(
+        name="mcp", description="Show MCP server status",
+        usage="/mcp [connect|disconnect <name>]", category="tools",
+    ))
+    registry.register(SlashCommand(
+        name="persona", description="Switch domain persona",
+        usage="/persona <slug|list|off>", category="agent",
+    ))
+    registry.register(SlashCommand(
+        name="trust", description="Show progressive trust stats",
+        usage="/trust", category="agent",
+    ))
+    registry.register(SlashCommand(
+        name="quit", description="Exit Elidia",
+        usage="/quit", category="general",
+    ))
+    registry.register(SlashCommand(
+        name="exit", description="Exit Elidia",
+        usage="/exit", category="general",
+    ))
+    registry.register(SlashCommand(
+        name="balance", description="Show API credit balance",
+        usage="/balance", category="general",
+    ))
+    registry.register(SlashCommand(
+        name="memory", description="View, search, save, or forget memories",
+        usage="/memory [list|search <query>|save key=value|forget <key>]",
+        category="memory",
+    ))
+    registry.register(SlashCommand(
+        name="history", description="Search chat history across sessions",
+        usage="/history [search query]", category="session",
+    ))
+    registry.register(SlashCommand(
+        name="rules", description="Show project rules (.elidia/rules.md)",
+        usage="/rules", category="general",
+    ))
+
+    return registry

elidia/cli/main.py

@@ -0,0 +1,293 @@
+import asyncio
+import logging
+import sys
+
+import click
+from rich.console import Console
+
+from elidia.config.defaults import VERSION
+
+console = Console()
+logger = logging.getLogger(__name__)
+
+
+def _setup_logging(debug: bool) -> None:
+    logger.debug("Entered into _setup_logging")
+    level = logging.DEBUG if debug else logging.WARNING
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+        handlers=[logging.StreamHandler(sys.stderr)],
+    )
+
+
+_DEFAULT_COMMAND_NAME = "__default__"
+
+
+class _ElidiaGroup(click.Group):
+    """Group that falls back to a hidden one-shot command for free-form messages.
+
+    Click has no built-in way to combine subcommands (``auth``, ``config`` ...)
+    with a catch-all positional message (``elidia "question"``): declaring a
+    ``nargs=-1`` argument directly on the group would swallow every token,
+    including real subcommand names, before dispatch ever runs. Instead this
+    tries normal subcommand resolution first and only falls back to the
+    hidden ``__default__`` command — treating the raw args as a
+    natural-language message — when nothing matches.
+    """
+
+    def resolve_command(self, ctx: click.Context, args: list[str]):
+        logger.debug(f"Entered into _ElidiaGroup.resolve_command: arg_count={len(args)}")
+        try:
+            return super().resolve_command(ctx, args)
+        except click.UsageError:
+            default_cmd = self.commands[_DEFAULT_COMMAND_NAME]
+            return _DEFAULT_COMMAND_NAME, default_cmd, args
+
+
+@click.group(cls=_ElidiaGroup, invoke_without_command=True)
+@click.option("--model", "-m", default=None, help="Override model selection")
+@click.option("--mode", default="chat", type=click.Choice(["chat", "code", "research", "think", "create"]))
+@click.option("--debug", is_flag=True, help="Enable debug logging")
+@click.option("--version", "-v", is_flag=True, help="Show version")
+@click.pass_context
+def cli(ctx: click.Context, model: str | None, mode: str, debug: bool, version: bool) -> None:
+    """Elidia — Universal AI Agent for your terminal."""
+    _setup_logging(debug)
+    logger.debug("Entered into cli")
+
+    if version:
+        console.print(f"elidia-cli v{VERSION}")
+        ctx.exit()
+
+    ctx.ensure_object(dict)
+    ctx.obj["model"] = model
+    ctx.obj["mode"] = mode
+    ctx.obj["debug"] = debug
+
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if not sys.stdin.isatty():
+        stdin_content = sys.stdin.read().strip()
+        if stdin_content:
+            asyncio.run(_one_shot(stdin_content, model=model, mode=mode))
+            return
+
+    asyncio.run(_start_repl(model=model, mode=mode))
+
+
+@click.command(name=_DEFAULT_COMMAND_NAME, hidden=True)
+@click.argument("message", nargs=-1)
+@click.pass_context
+def _default_message(ctx: click.Context, message: tuple[str, ...]) -> None:
+    """Hidden fallback: any input that isn't a known subcommand is a one-shot message."""
+    logger.debug(f"Entered into _default_message: token_count={len(message)}")
+    user_msg = " ".join(message).strip()
+    if not user_msg:
+        return
+    model = ctx.obj.get("model") if ctx.obj else None
+    mode = ctx.obj.get("mode", "chat") if ctx.obj else "chat"
+    asyncio.run(_one_shot(user_msg, model=model, mode=mode))
+
+
+cli.add_command(_default_message)
+
+
+@cli.command("ask")
+@click.argument("message", nargs=-1, required=True)
+@click.option("--model", "-m", default=None, help="Override model selection")
+@click.option("--mode", default=None, type=click.Choice(["chat", "code", "research", "think", "create"]))
+@click.pass_context
+def ask(ctx: click.Context, message: tuple[str, ...], model: str | None, mode: str | None) -> None:
+    """Send a one-shot message: elidia ask 'your question here'"""
+    logger.debug("Entered into ask")
+    parent = ctx.parent
+    parent_obj = parent.obj if parent and parent.obj else {}
+    model = model or parent_obj.get("model")
+    mode = mode or parent_obj.get("mode") or "chat"
+    user_msg = " ".join(message)
+    asyncio.run(_one_shot(user_msg, model=model, mode=mode))
+
+
+async def _one_shot(message: str, model: str | None = None, mode: str = "chat") -> None:
+    logger.debug(f"Entered into _one_shot: msg_len={len(message)}")
+    from elidia.cli.repl import ElidiaRepl
+
+    repl = ElidiaRepl(forced_model=model, mode=mode)
+    await repl.initialize()
+    await repl.send_message(message, interactive=False)
+    await repl.cleanup()
+
+
+async def _start_repl(model: str | None = None, mode: str = "chat") -> None:
+    logger.debug("Entered into _start_repl")
+    from elidia.cli.repl import ElidiaRepl
+
+    repl = ElidiaRepl(forced_model=model, mode=mode)
+    await repl.initialize()
+    await repl.run()
+    await repl.cleanup()
+
+
+# --- Auth subcommands ---
+
+
+@cli.group()
+def auth() -> None:
+    """Manage API key authentication."""
+
+
+@auth.command("login")
+def auth_login() -> None:
+    """Store your AiUtils API key."""
+    logger.debug("Entered into auth_login")
+    from elidia.auth.keychain import mask_api_key, store_api_key, validate_api_key
+
+    key = click.prompt("Enter your AiUtils API key (get one at developer.aiutils.io)", hide_input=True)
+    if not validate_api_key(key):
+        console.print("[red]Invalid key format. Keys start with 'ak-dev-'.[/red]")
+        raise SystemExit(1)
+    store_api_key(key)
+    console.print(f"[green]v[/green] API key stored: {mask_api_key(key)}")
+
+
+@auth.command("logout")
+def auth_logout() -> None:
+    """Remove stored API key."""
+    logger.debug("Entered into auth_logout")
+    from elidia.auth.keychain import delete_api_key
+
+    delete_api_key()
+    console.print("[green]v[/green] API key removed.")
+
+
+@auth.command("status")
+def auth_status() -> None:
+    """Show API key status and balance."""
+    logger.debug("Entered into auth_status")
+    from elidia.auth.keychain import get_api_key, mask_api_key
+
+    key = get_api_key()
+    if not key:
+        console.print("[yellow]No API key configured.[/yellow] Run: elidia auth login")
+        return
+    console.print(f"API Key: {mask_api_key(key)}")
+
+    async def _show_balance() -> None:
+        from elidia.api.client import AiUtilsClient
+        from elidia.config.settings import load_config
+
+        config = load_config()
+        client = AiUtilsClient(api_key=key, base_url=config.api.base_url)
+        balance = await client.get_balance()
+        await client.close()
+        if balance.get("balance_dt", -1) >= 0:
+            console.print(f"Balance: {balance['balance_dt']:,.0f} DT (${balance['balance_dt'] / 1000:.2f})")
+        else:
+            console.print(f"[yellow]Could not fetch balance: {balance.get('error', 'unknown')}[/yellow]")
+
+    asyncio.run(_show_balance())
+
+
+# --- Config subcommands ---
+
+
+@cli.group()
+def config() -> None:
+    """View and manage configuration."""
+
+
+@config.command("show")
+def config_show() -> None:
+    """Show effective configuration."""
+    logger.debug("Entered into config_show")
+    import dataclasses
+    import json
+
+    from elidia.auth.keychain import mask_api_key
+    from elidia.config.settings import ELIDIA_HOME, load_config
+
+    cfg = load_config()
+    d = dataclasses.asdict(cfg)
+    if d.get("api", {}).get("key"):
+        d["api"]["key"] = mask_api_key(d["api"]["key"])
+    console.print_json(json.dumps(d, indent=2))
+    console.print(f"\n[dim]Config dir: {ELIDIA_HOME}[/dim]")
+
+
+# --- Session subcommands ---
+
+
+@cli.group()
+def session() -> None:
+    """Manage chat sessions."""
+
+
+@session.command("list")
+def session_list() -> None:
+    """List recent sessions."""
+    logger.debug("Entered into session_list")
+    from rich.table import Table
+
+    from elidia.db.database import Database
+    from elidia.session.manager import SessionManager
+
+    db = Database()
+    db.connect()
+    mgr = SessionManager(db)
+    sessions = mgr.list_sessions()
+    db.close()
+
+    if not sessions:
+        console.print("[dim]No sessions yet. Start chatting to create one.[/dim]")
+        return
+
+    table = Table(title="Sessions")
+    table.add_column("ID", style="dim", max_width=8)
+    table.add_column("Title")
+    table.add_column("Model", style="cyan")
+    table.add_column("Updated", style="green")
+
+    for s in sessions:
+        table.add_row(s["id"][:8], s["title"], s.get("model") or "auto", s["updated_at"])
+
+    console.print(table)
+
+
+@session.command("new")
+def session_new() -> None:
+    """Create a new session."""
+    logger.debug("Entered into session_new")
+    from elidia.db.database import Database
+    from elidia.session.manager import SessionManager
+
+    db = Database()
+    db.connect()
+    mgr = SessionManager(db)
+    sid = mgr.create_session()
+    db.close()
+    console.print(f"[green]v[/green] Created session: {sid[:8]}")
+
+
+@session.command("delete")
+@click.argument("session_id")
+def session_delete(session_id: str) -> None:
+    """Delete a session."""
+    logger.debug(f"Entered into session_delete: {session_id}")
+    from elidia.db.database import Database
+    from elidia.session.manager import SessionManager
+
+    db = Database()
+    db.connect()
+    mgr = SessionManager(db)
+    mgr.delete_session(session_id)
+    db.close()
+    console.print("[green]v[/green] Deleted session.")
+
+
+@cli.command("version")
+def show_version() -> None:
+    """Show version information."""
+    logger.debug("Entered into show_version")
+    console.print(f"elidia-cli v{VERSION}")

elidia/cli/pager.py

@@ -0,0 +1,104 @@
+"""Auto-pager — pages long output through the terminal pager.
+
+When output exceeds the terminal height, it is automatically routed
+through Rich's built-in pager (which uses the system's PAGER env var,
+defaulting to 'less -R' on Unix or 'more' on Windows).
+
+The pager is only engaged for non-interactive, non-streaming content.
+Streaming responses are always rendered directly.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+
+from rich.console import Console
+from rich.markdown import Markdown
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_PAGER_THRESHOLD = 0.8
+
+
+class AutoPager:
+    """Automatically pages output when it exceeds terminal height."""
+
+    def __init__(
+        self,
+        console: Console | None = None,
+        threshold: float = DEFAULT_PAGER_THRESHOLD,
+        enabled: bool = True,
+    ) -> None:
+        logger.debug(f"Entered into AutoPager.__init__: threshold={threshold}, enabled={enabled}")
+        self._console = console or Console()
+        self._threshold = threshold
+        self._enabled = enabled
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self._enabled = value
+
+    @property
+    def threshold(self) -> float:
+        return self._threshold
+
+    def get_terminal_height(self) -> int:
+        logger.debug("Entered into get_terminal_height")
+        size = shutil.get_terminal_size(fallback=(80, 24))
+        return size.lines
+
+    def should_page(self, content: str) -> bool:
+        logger.debug("Entered into should_page")
+        if not self._enabled:
+            return False
+        if not content:
+            return False
+
+        term_height = self.get_terminal_height()
+        content_lines = content.count("\n") + 1
+        threshold_lines = int(term_height * self._threshold)
+
+        return content_lines > threshold_lines
+
+    def print_or_page(self, content: str, as_markdown: bool = True) -> None:
+        logger.debug(f"Entered into print_or_page: len={len(content)}, md={as_markdown}")
+        if self.should_page(content):
+            self._page(content, as_markdown)
+        else:
+            self._print(content, as_markdown)
+
+    def _print(self, content: str, as_markdown: bool) -> None:
+        logger.debug("Entered into _print")
+        if as_markdown:
+            try:
+                self._console.print(Markdown(content))
+            except Exception:
+                self._console.print(content)
+        else:
+            self._console.print(content)
+
+    def _page(self, content: str, as_markdown: bool) -> None:
+        logger.debug("Entered into _page")
+        try:
+            with self._console.pager(styles=as_markdown):
+                if as_markdown:
+                    self._console.print(Markdown(content))
+                else:
+                    self._console.print(content)
+        except Exception as e:
+            logger.warning(f"Pager failed, falling back to direct print: {e}")
+            self._print(content, as_markdown)
+
+    def page_lines(self, lines: list[str]) -> None:
+        logger.debug(f"Entered into page_lines: count={len(lines)}")
+        content = "\n".join(lines)
+        self.print_or_page(content, as_markdown=False)
+
+    def get_pager_command(self) -> str:
+        logger.debug("Entered into get_pager_command")
+        return os.environ.get("PAGER", "less -R")

elidia/cli/progress.py

@@ -0,0 +1,173 @@
+"""Progress indicators — spinners and progress bars for async operations.
+
+Provides reusable wrappers around Rich's progress display components:
+  - Spinner: for indeterminate-length operations (LLM generation, search)
+  - ProgressBar: for determinate operations (file download, batch processing)
+  - StageTracker: for multi-stage pipelines (research, workflow)
+"""
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import AsyncIterator, Iterator
+from contextlib import asynccontextmanager, contextmanager
+
+from rich.console import Console
+from rich.live import Live
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+from rich.spinner import Spinner
+from rich.text import Text
+
+logger = logging.getLogger(__name__)
+
+
+@contextmanager
+def spinner(
+    console: Console,
+    message: str = "Working...",
+    spinner_name: str = "dots",
+    style: str = "cyan",
+) -> Iterator[Live]:
+    logger.debug(f"Entered into spinner: message={message}")
+    display = Text.assemble(
+        (" ", ""),
+        (message, style),
+    )
+    spin = Spinner(spinner_name, text=display, style=style)
+    with Live(spin, console=console, transient=True, refresh_per_second=12) as live:
+        yield live
+
+
+@asynccontextmanager
+async def async_spinner(
+    console: Console,
+    message: str = "Working...",
+    spinner_name: str = "dots",
+    style: str = "cyan",
+) -> AsyncIterator[Live]:
+    logger.debug(f"Entered into async_spinner: message={message}")
+    display = Text.assemble(
+        (" ", ""),
+        (message, style),
+    )
+    spin = Spinner(spinner_name, text=display, style=style)
+    with Live(spin, console=console, transient=True, refresh_per_second=12) as live:
+        yield live
+
+
+def create_progress_bar(
+    console: Console,
+    transient: bool = True,
+) -> Progress:
+    logger.debug("Entered into create_progress_bar")
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(bar_width=30),
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+        TimeRemainingColumn(),
+        console=console,
+        transient=transient,
+    )
+
+
+class StageTracker:
+    """Tracks progress through a multi-stage pipeline."""
+
+    def __init__(self, console: Console, stages: list[str]) -> None:
+        logger.debug(f"Entered into StageTracker.__init__: stages={len(stages)}")
+        self._console = console
+        self._stages = stages
+        self._current: int = -1
+        self._completed: list[bool] = [False] * len(stages)
+        self._timings: list[float] = [0.0] * len(stages)
+        self._start_time: float = 0.0
+
+    def start(self) -> None:
+        logger.debug("Entered into StageTracker.start")
+        self._start_time = time.monotonic()
+
+    def advance(self, stage_index: int | None = None) -> None:
+        logger.debug(f"Entered into StageTracker.advance: index={stage_index}")
+        if self._current >= 0 and self._current < len(self._stages):
+            self._completed[self._current] = True
+            self._timings[self._current] = time.monotonic() - self._start_time
+
+        if stage_index is not None:
+            self._current = stage_index
+        else:
+            self._current += 1
+
+        if self._current < len(self._stages):
+            self._start_time = time.monotonic()
+            name = self._stages[self._current]
+            progress = f"[{self._current + 1}/{len(self._stages)}]"
+            self._console.print(f"  [cyan]{progress}[/cyan] {name}")
+
+    def complete(self) -> None:
+        logger.debug("Entered into StageTracker.complete")
+        if self._current >= 0 and self._current < len(self._stages):
+            self._completed[self._current] = True
+            self._timings[self._current] = time.monotonic() - self._start_time
+
+    def render_summary(self) -> None:
+        logger.debug("Entered into StageTracker.render_summary")
+        total_time = sum(self._timings)
+        completed = sum(1 for c in self._completed if c)
+        self._console.print(
+            f"\n[bold]Pipeline:[/bold] {completed}/{len(self._stages)} stages "
+            f"({total_time:.1f}s)"
+        )
+
+    @property
+    def current_stage(self) -> str | None:
+        if 0 <= self._current < len(self._stages):
+            return self._stages[self._current]
+        return None
+
+    @property
+    def is_complete(self) -> bool:
+        return all(self._completed)
+
+
+class DownloadTracker:
+    """Tracks file download progress."""
+
+    def __init__(self, console: Console) -> None:
+        logger.debug("Entered into DownloadTracker.__init__")
+        self._console = console
+        self._progress: Progress | None = None
+        self._task_id: TaskID | None = None
+
+    def start(self, filename: str, total_bytes: int) -> Progress:
+        logger.debug(f"Entered into DownloadTracker.start: file={filename}, bytes={total_bytes}")
+        self._progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(bar_width=30),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeElapsedColumn(),
+            console=self._console,
+            transient=True,
+        )
+        self._task_id = self._progress.add_task(filename, total=total_bytes)
+        return self._progress
+
+    def update(self, bytes_downloaded: int) -> None:
+        if self._progress and self._task_id is not None:
+            self._progress.update(self._task_id, completed=bytes_downloaded)
+
+    def finish(self) -> None:
+        logger.debug("Entered into DownloadTracker.finish")
+        if self._progress and self._task_id is not None:
+            self._progress.update(self._task_id, completed=self._progress.tasks[0].total or 0)