elidia-agent-cli 0.2.0__tar.gz → 0.4.0__tar.gz

elidia_agent_cli-0.4.0/CHANGELOG.md

@@ -0,0 +1,56 @@
+# Changelog
+
+All notable changes to Elidia CLI will be documented in this file.
+
+## [0.3.0] - 2026-07-27
+
+### Added
+- RAG reconnected to every user-facing surface: `elidia rag ingest/search/list/clear`
+  (CLI), `/rag ingest|search|list|clear` (REPL), and auto-ingest for files over
+  ~8,000 chars passed via `-f/--file` (preview + index instead of blind truncation,
+  including files >1MB that were previously dropped entirely). New agent-facing
+  `rag_search`/`rag_list_sources` tools (AUTO permission tier).
+
+### Fixed
+- `elidia workflow run` required an API key even for pure-shell workflows with no
+  `llm` step.
+- Email skill used the same field for the SMTP/IMAP login and the visible `From`
+  address, which breaks for transactional relays (Zepto, SendGrid, Mailgun, SES)
+  whose AUTH username is a token distinct from the sender address. Added
+  `from_address`.
+- RAG's FTS5 query builder crashed on any hyphenated search term (`"no such
+  column: call"` on a query containing "on-call").
+- RAG's chunker never split a paragraph/section/line once it exceeded
+  `chunk_size` — a 21KB file with no blank lines produced 1 chunk instead of
+  ~40, diluting the embedding enough that content buried mid-file became
+  unfindable by search.
+- `elidia ask` silently dropped `-f/--file` — the subcommand never declared its
+  own option or read the parent group's.
+
+## [0.2.0] - 2026-07-26
+
+### Added
+- Real background daemon (`elidia daemon start/stop/restart/status/init`),
+  `elidia mcp list/health`, `elidia workflow run`.
+- Vision support: `--image`/`-i` flag, `/image` REPL command, S3/CDN upload.
+- Browser, Office, Database, Email, and Calendar skills (5 new tool categories).
+
+### Fixed
+- Tool-calling never actually worked — the system prompt (and therefore every
+  tool schema) was never sent to the model; the agent could only ever respond
+  from training knowledge, never call a real tool.
+- Permission classification for tool calls with an omitted path argument fell
+  through to the wrong (over-restrictive) tier.
+
+## [0.1.0] - 2026-07-25
+
+### Added
+- Phase 0: Core CLI framework (Click + Rich + prompt_toolkit)
+- Phase 1: MCP integration, built-in tools, model router, permissions
+- Phase 2: Persistent memory (sqlite-vec), RAG engine, session management
+- Phase 3: Advanced modes (classifier, consensus, deep think, autonomous, swarm)
+- Phase 3: Research pipeline (YOYO 5-stage), creative generation, workflow engine
+- Phase 3: Daemon mode, widget protocol, terminal image display
+- Phase 4: Auto-pager, progress indicators, response cache, configurable themes
+- Phase 4: Connection pooling (httpx HTTP/2), PyPI packaging, CI/CD pipeline
+- Phase 4: Automated test suite, MkDocs documentation site

{elidia_agent_cli-0.2.0/elidia_agent_cli.egg-info → elidia_agent_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elidia-agent-cli
-Version: 0.2.0
+Version: 0.4.0
 Summary: Elidia Agent CLI — Universal AI Agent for your terminal
 Author-email: Elidia Technology Pvt Ltd <support@aiutils.io>
 License-Expression: LicenseRef-Proprietary
@@ -136,6 +136,20 @@ Powered by the [AiUtils Developer API](https://developer.aiutils.io), Elidia Age
 
 ```bash
 pip install elidia-agent-cli
+elidia auth login          # enter your AiUtils API key
+elidia ask "Hello!"        # send your first message
+```
+
+**If `elidia` command not found after install**, add pip's bin directory to PATH:
+
+```bash
+# Add to ~/.zshrc (macOS/Linux) to make permanent:
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
+source ~/.zshrc
+
+# Or for bash:
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
 ```
 
 ### From GitHub Release
@@ -143,13 +157,14 @@ pip install elidia-agent-cli
 Download the latest `.whl` file from [Releases](https://github.com/Elidia-Technology/elidia-agent-cli/releases), then:
 
 ```bash
-pip install elidia_agent_cli-0.1.0-py3-none-any.whl
+pip install elidia_agent_cli-0.3.0-py3-none-any.whl
 ```
 
 ### Requirements
 
 - Python 3.11 or higher
 - An AiUtils Developer API key ([get one here](https://developer.aiutils.io))
+- macOS 12+, Ubuntu 22.04+, or Windows 10+
 
 ---
 

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.4.0}/README.md

@@ -76,6 +76,20 @@ Powered by the [AiUtils Developer API](https://developer.aiutils.io), Elidia Age
 
 ```bash
 pip install elidia-agent-cli
+elidia auth login          # enter your AiUtils API key
+elidia ask "Hello!"        # send your first message
+```
+
+**If `elidia` command not found after install**, add pip's bin directory to PATH:
+
+```bash
+# Add to ~/.zshrc (macOS/Linux) to make permanent:
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
+source ~/.zshrc
+
+# Or for bash:
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
 ```
 
 ### From GitHub Release
@@ -83,13 +97,14 @@ pip install elidia-agent-cli
 Download the latest `.whl` file from [Releases](https://github.com/Elidia-Technology/elidia-agent-cli/releases), then:
 
 ```bash
-pip install elidia_agent_cli-0.1.0-py3-none-any.whl
+pip install elidia_agent_cli-0.3.0-py3-none-any.whl
 ```
 
 ### Requirements
 
 - Python 3.11 or higher
 - An AiUtils Developer API key ([get one here](https://developer.aiutils.io))
+- macOS 12+, Ubuntu 22.04+, or Windows 10+
 
 ---
 

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.4.0}/docs/ARCHITECTURE_FLOWCHARTS.md

@@ -788,3 +788,43 @@ are now permanently exempt from promotion, proven with a regression test
 showing 25 consecutive approvals still prompt on the 26th call. See the
 master plan (`06_CLI_AND_DESKTOP_MASTER_PLAN.md`, §4.4) for full detail
 and commit references.
+
+## 22. RAG Subsystem — Reconnected (2026-07-27, AIUT-2141)
+
+`RagEngine`/`FileIngestPipeline` existed (~1,135 LOC) but were never
+called from any user-facing surface — confirmed via `grep -rn
+"FileIngestPipeline(\|RagEngine(" elidia/` returning zero hits outside
+`elidia/rag/` itself. Wired up per the requested design (all three, not
+one-or-the-other): `elidia rag ingest/search/list/clear` (CLI), `/rag
+...` (REPL), and auto-ingest for files over ~8,000 chars passed via
+`-f/--file` (preview + index instead of blind truncation, including the
+>1MB case that previously just dropped the file). The read side is a new
+`rag_search` tool (AUTO tier, agent-invocable) — ingestion stays a
+deliberate user action across all three entry points, never
+agent-triggered, so an embedding-cost operation can't fire mid-conversation
+without the user asking for it.
+
+Live end-to-end verification surfaced and fixed three further real bugs
+along the way, not just wiring:
+
+1. **FTS5 query builder crashed on hyphenated terms** — `_build_fts_query`
+   escaped special characters individually but not `-`, and FTS5's query
+   grammar treats an in-word hyphen as syntax (`on-call*` → `no such
+   column: call`), not just a tokenizer boundary. Fixed by quoting every
+   term (`"on-call"*`) instead of trying to enumerate escapable characters.
+2. **Chunker never split an oversized paragraph/section/line** — a 21KB
+   file with no blank lines produced *one* chunk containing the entire
+   file instead of ~40, diluting the embedding enough that a fact in the
+   middle became unfindable by search. Fixed for all three content types
+   (`text`, `markdown`, `code`) via a shared `_split_oversized` helper.
+3. **`elidia ask` silently dropped `-f/--file`** — the subcommand never
+   declared its own `--file` option and never read the parent group's
+   either, so both `elidia ask -f x.txt "..."` and `elidia --file x.txt
+   ask "..."` reached the model with nothing attached. Fixed by mirroring
+   how `-i/--image` already worked (own option + parent fallback).
+
+34 new tests added across `test_rag_tool.py` and `test_chunker.py`
+(chunker fix verified with a real FTS5 in-memory table, not just string
+inspection). Full live proof, not just unit tests: real `elidia rag
+ingest` → real `elidia ask` with the agent autonomously calling
+`rag_search` → correct grounded answer citing the ingested content.

elidia_agent_cli-0.4.0/docs/guide/tools-mcp.md

@@ -0,0 +1,113 @@
+# Tools & MCP
+
+## Built-in Tools
+
+Elidia ships with tools in several categories:
+
+| Category | Tools | Description |
+|----------|-------|-------------|
+| `filesystem` | read, write, edit, list, glob, grep | File operations |
+| `terminal` | command_exec | Shell command execution |
+| `git` | status, diff, log, commit, branch | Git workflow |
+| `search` / `fetch` | web_search, http_fetch | Web requests and search |
+| `browser` | navigate, click, type, screenshot, extract_links | Headless browser automation (Playwright) |
+| `office` | read/write docx, read/write xlsx, read pptx | Office document parsing |
+| `database` | connect, query, list_tables, describe_table | Read-only SQL |
+| `email` | send, search, read | SMTP send / IMAP search+read |
+| `calendar` | list_events, add_event, find_conflicts | Local .ics calendar |
+| `rag` | rag_search, rag_list_sources | Search content ingested into the local RAG store |
+
+View all tools:
+
+```
+> /tools
+> /tools filesystem      # Filter by category
+```
+
+## RAG (Retrieval-Augmented Search)
+
+Large files don't need to fit in the conversation — Elidia can index them
+into a local RAG store (sqlite-vec, hybrid BM25 + semantic search) and
+retrieve relevant chunks on demand via the `rag_search` tool. Three ways
+to get content in:
+
+```
+elidia rag ingest <path>        # explicit, works on a file or a directory
+> /rag ingest <path>            # same, from inside the REPL
+> /rag search <query>           # search without waiting for the agent to do it
+elidia ask -f big_file.md "..." # auto-ingest: files over ~8,000 chars are
+                                 # previewed + indexed instead of truncated
+```
+
+`elidia rag list` / `/rag list` shows how much is currently ingested;
+`elidia rag clear` / `/rag clear` empties the store. Ingestion is always
+a deliberate, user-triggered action (CLI command, slash command, or the
+`-f` auto-ingest path) — the agent can search what's already ingested via
+`rag_search`, but never triggers ingestion on its own mid-conversation.
+
+## Permissions
+
+Tools require user approval based on risk level:
+
+- **Read** — auto-approved by default
+- **Write** — requires approval
+- **Shell** — requires approval
+- **Web** — configurable
+
+The trust engine learns from your decisions:
+
+```
+> /trust                 # Show trust stats
+```
+
+After consistently approving an action, Elidia auto-promotes it (no more prompts).
+
+## MCP Integration
+
+Elidia supports [Model Context Protocol](https://modelcontextprotocol.io/) servers for extending tool capabilities.
+
+### Configuration
+
+Add MCP servers to `~/.elidia/mcp.json`:
+
+```json
+{
+  "servers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user"]
+    },
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_TOKEN": "ghp_..."
+      }
+    }
+  }
+}
+```
+
+### Managing MCP Servers
+
+```
+> /mcp                          # List connected servers
+> /mcp disconnect github        # Disconnect a server
+```
+
+MCP tools appear alongside built-in tools and are invoked with the same permission system.
+
+## Tool Execution Flow
+
+```mermaid
+graph TD
+    A[User Query] --> B{Agent Loop}
+    B --> C[LLM decides tool call]
+    C --> D{Permission Check}
+    D -->|Approved| E[Execute Tool]
+    D -->|Denied| F[Report to LLM]
+    E --> G[Return Result to LLM]
+    G --> B
+    F --> B
+    B --> H[Final Response]
+```

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.4.0}/elidia/agent/loop.py

@@ -210,7 +210,7 @@ class AgentLoop:
 
                 if self._permissions:
                     action_type = self._classify_tool_action(tool_name, tool_args)
-                    allowed = self._permissions.check(
+                    allowed = await self._permissions.check(
                         action=action_type,
                         session_id=session_id,
                         path=tool_args.get("path"),
@@ -482,6 +482,8 @@ class AgentLoop:
             "calendar_list_events": "file_read",
             "calendar_find_conflicts": "file_read",
             "calendar_add_event": "file_write",
+            "rag_search": "rag_search",
+            "rag_list_sources": "rag_search",
         }
         return action_map.get(tool_name, "mcp_call_session")
 

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.4.0}/elidia/cli/commands.py

@@ -118,5 +118,10 @@ def build_default_commands() -> CommandRegistry:
         name="rules", description="Show project rules (.elidia/rules.md)",
         usage="/rules", category="general",
     ))
+    registry.register(SlashCommand(
+        name="rag", description="Ingest files or search the local RAG store",
+        usage="/rag [ingest <path>|search <query>|list|clear]",
+        category="tools",
+    ))
 
     return registry

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.4.0}/elidia/cli/main.py

@@ -110,9 +110,11 @@ cli.add_command(_default_message)
 @click.option("--mode", default=None, type=click.Choice(["chat", "code", "research", "think", "create"]))
 @click.option("--image", "-i", "images", multiple=True, type=click.Path(exists=True),
               help="Attach an image for vision analysis (repeatable, jpg/png/webp/gif)")
+@click.option("--file", "-f", "files", multiple=True, type=click.Path(exists=True),
+              help="Include file content in context (repeatable)")
 @click.pass_context
 def ask(ctx: click.Context, message: tuple[str, ...], model: str | None, mode: str | None,
-        images: tuple[str, ...]) -> None:
+        images: tuple[str, ...], files: tuple[str, ...]) -> None:
     """Send a one-shot message: elidia ask 'your question here'"""
     logger.debug("Entered into ask")
     parent = ctx.parent
@@ -120,8 +122,9 @@ def ask(ctx: click.Context, message: tuple[str, ...], model: str | None, mode: s
     model = model or parent_obj.get("model")
     mode = mode or parent_obj.get("mode") or "chat"
     images = images or parent_obj.get("images", ())
+    files = files or parent_obj.get("files", ())
     user_msg = " ".join(message)
-    asyncio.run(_one_shot(user_msg, model=model, mode=mode, images=images))
+    asyncio.run(_one_shot(user_msg, model=model, mode=mode, images=images, files=files))
 
 
 _IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tiff", ".heic"}
@@ -153,8 +156,47 @@ def _summarize_ics(path: Path) -> str:
     return "\n".join(lines) if lines else "[No events in this calendar]"
 
 
-def _build_file_context(files: tuple[str, ...]) -> str:
-    """Read file contents and build a context prefix for the message."""
+_AUTO_INGEST_THRESHOLD = 8_000  # chars — beyond this, index into RAG + preview instead of blind truncation
+
+
+async def _auto_ingest_file(path: Path, content: str) -> bool:
+    """Best-effort: index a large file into the local RAG store so it's
+    retrievable via rag_search instead of being silently truncated.
+    Returns False (never raises) if no API key is configured or ingestion
+    fails for any reason — callers fall back to plain truncation."""
+    logger.debug(f"Entered into _auto_ingest_file: path={path}")
+    from elidia.auth.keychain import get_api_key
+
+    api_key = get_api_key()
+    if not api_key:
+        return False
+
+    try:
+        import hashlib
+
+        from elidia.memory.embeddings import EmbeddingClient
+        from elidia.rag.engine import RagEngine
+
+        engine = RagEngine(EmbeddingClient(api_key=api_key))
+        engine.open()
+        try:
+            file_hash = hashlib.sha256(content.encode()).hexdigest()[:16]
+            await engine.ingest(text=content, source=str(path.resolve()), file_hash=file_hash)
+        finally:
+            engine.close()
+        return True
+    except Exception as e:
+        logger.warning(f"Entered into _auto_ingest_file: auto-ingest failed for {path}: {e}")
+        return False
+
+
+async def _build_file_context(files: tuple[str, ...]) -> str:
+    """Read file contents and build a context prefix for the message.
+
+    Files larger than _AUTO_INGEST_THRESHOLD are indexed into the local
+    RAG store (auto-ingest) instead of being blindly truncated — the
+    message gets a preview plus a pointer to rag_search for the rest.
+    """
     if not files:
         return ""
     parts: list[str] = []
@@ -171,7 +213,14 @@ def _build_file_context(files: tuple[str, ...]) -> str:
         try:
             size = path.stat().st_size
             if size > 1_000_000:
-                parts.append(f"[File too large to include: {path.name} ({size} bytes)]")
+                ingested = await _auto_ingest_file(path, path.read_text(encoding="utf-8", errors="replace"))
+                if ingested:
+                    parts.append(
+                        f"[{path.name} ({size} bytes) is too large to inline but has been indexed "
+                        f"into the local RAG store — use rag_search to find relevant sections]"
+                    )
+                else:
+                    parts.append(f"[File too large to include: {path.name} ({size} bytes)]")
                 continue
             suffix = path.suffix.lower()
             if suffix in _OFFICE_PARSERS:
@@ -182,6 +231,15 @@ def _build_file_context(files: tuple[str, ...]) -> str:
                 content = _summarize_ics(path)
             else:
                 content = path.read_text(encoding="utf-8", errors="replace")
+
+            if len(content) > _AUTO_INGEST_THRESHOLD:
+                ingested = await _auto_ingest_file(path, content)
+                if ingested:
+                    preview = content[:_AUTO_INGEST_THRESHOLD] + "\n... (truncated — indexed into RAG, use rag_search for the rest)"
+                    parts.append(f"--- {path.name} (preview, {len(content)} chars total, indexed into RAG) ---\n{preview}\n--- end {path.name} preview ---")
+                    total += _AUTO_INGEST_THRESHOLD
+                    continue
+
             if total + len(content) > max_total:
                 content = content[:max_total - total] + "\n... (truncated)"
             parts.append(f"--- {path.name} ---\n{content}\n--- end {path.name} ---")
@@ -200,7 +258,7 @@ async def _one_shot(message: str, model: str | None = None, mode: str = "chat",
     )
     from elidia.cli.repl import ElidiaRepl
 
-    file_ctx = _build_file_context(files)
+    file_ctx = await _build_file_context(files)
     full_message = f"{file_ctx}{message}" if file_ctx else message
 
     repl = ElidiaRepl(forced_model=model, mode=mode)
@@ -364,6 +422,54 @@ def config_show() -> None:
     console.print(f"\n[dim]Config dir: {ELIDIA_HOME}[/dim]")
 
 
+@config.command("set")
+@click.argument("key")
+@click.argument("value")
+def config_set(key: str, value: str) -> None:
+    """Set a configuration value. Examples:
+    elidia config set models.default gpt-4o
+    elidia config set models.code claude-sonnet-4-6
+    elidia config set budget.session_limit_dt 100000
+    elidia config set permissions.auto_approve_commands true
+    """
+    logger.debug(f"Entered into config_set: key={key}, value={value}")
+    from elidia.config.settings import ELIDIA_HOME, load_config, save_config
+
+    cfg = load_config()
+    parts = key.split(".")
+    if len(parts) != 2:
+        console.print("[red]Key must be in format: section.field (e.g., models.default)[/red]")
+        return
+
+    section_name, field_name = parts
+    section = getattr(cfg, section_name, None)
+    if section is None:
+        console.print(f"[red]Unknown section: {section_name}[/red] Available: {[f.name for f in dataclasses.fields(cfg)]}")
+        return
+
+    if not hasattr(section, field_name):
+        console.print(f"[red]Unknown field: {field_name}[/red] Available: {[f.name for f in dataclasses.fields(section)]}")
+        return
+
+    # Coerce value to the correct type
+    current = getattr(section, field_name)
+    if isinstance(current, bool):
+        val = value.lower() in ("true", "yes", "1", "on")
+    elif isinstance(current, int):
+        val = int(value)
+    elif isinstance(current, float):
+        val = float(value)
+    elif isinstance(current, list):
+        val = [v.strip() for v in value.split(",")]
+    else:
+        val = value
+
+    setattr(section, field_name, val)
+    save_config(cfg, ELIDIA_HOME / "config.toml")
+    console.print(f"[green]v[/green] {key} = {val}")
+    console.print(f"[dim]Saved to {ELIDIA_HOME / 'config.toml'}[/dim]")
+
+
 # --- Session subcommands ---
 
 
@@ -643,3 +749,188 @@ def workflow_run(path: str) -> None:
                 await client.close()
 
     asyncio.run(_run())
+
+
+# --- Models command ---
+
+@cli.command("models")
+@click.option("--local", is_flag=True, help="Show only locally available models (Ollama)")
+def models_cmd(local: bool) -> None:
+    """List available AI models."""
+    logger.debug(f"Entered into models_cmd: local={local}")
+    if local:
+        from elidia.models.local import list_local_models
+        async def _run():
+            models = await list_local_models()
+            if not models:
+                console.print("[yellow]No local models found. Install Ollama and pull a model.[/yellow]")
+                return
+            console.print(f"\n[bold]Local Models (Ollama)[/bold]\n")
+            for m in models:
+                console.print(f"  [cyan]{m.name}[/cyan]  {m.parameter_size}  {m.context_length} ctx  caps: {', '.join(m.capabilities[:3])}")
+            console.print(f"\n[dim]{len(models)} model(s) available locally[/dim]")
+        return asyncio.run(_run())
+
+    from elidia.auth.keychain import get_api_key
+    from elidia.config.settings import load_config
+    from elidia.api.client import AiUtilsClient
+    api_key = get_api_key()
+    if not api_key:
+        console.print("[red]No API key configured. Run: elidia auth login[/red]")
+        return
+    config = load_config()
+
+    async def _run_remote():
+        client = AiUtilsClient(api_key=api_key, base_url=config.api.base_url)
+        try:
+            models = await client.list_models()
+            if not models:
+                console.print("[yellow]No models returned from API.[/yellow]")
+                return
+            console.print(f"\n[bold]Available Models ({len(models)} total)[/bold]\n")
+            for m in models:
+                name = m.get("id", m.get("name", "?"))
+                provider = m.get("owned_by", m.get("provider", "?"))
+                cost = m.get("pricing", {}).get("input", "?")
+                caps = []
+                if m.get("supports_vision"): caps.append("vision")
+                if m.get("supports_reasoning"): caps.append("reasoning")
+                if m.get("supports_tools"): caps.append("tools")
+                cap_str = f"[dim]({', '.join(caps)})[/dim]" if caps else ""
+                console.print(f"  [cyan]{name}[/cyan] @ [dim]{provider}[/dim] {cap_str}")
+            console.print(f"\n[dim]Use: elidia --model <name> ask '...'  |  /model <name> in REPL[/dim]")
+        finally:
+            await client.close()
+    asyncio.run(_run_remote())
+
+
+# --- RAG subcommands ---
+
+
+async def _open_rag_engine():
+    """Shared setup for the rag CLI subcommands: real API key required
+    (embeddings go through the AiUtils API), console error + SystemExit(1)
+    if missing so every subcommand fails the same clear way."""
+    from elidia.auth.keychain import get_api_key
+    from elidia.memory.embeddings import EmbeddingClient
+    from elidia.rag.engine import RagEngine
+
+    api_key = get_api_key()
+    if not api_key:
+        console.print("[red]No API key configured. Run: elidia auth login[/red]")
+        console.print("[dim]RAG ingestion/search needs it for embeddings.[/dim]")
+        raise SystemExit(1)
+
+    engine = RagEngine(EmbeddingClient(api_key=api_key))
+    engine.open()
+    return engine
+
+
+@cli.group()
+def rag() -> None:
+    """Manage the local RAG (retrieval-augmented search) store."""
+
+
+@rag.command("ingest")
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--recursive/--no-recursive", default=True, help="Recurse into subdirectories (directories only)")
+def rag_ingest(path: str, recursive: bool) -> None:
+    """Ingest a file or directory into the local RAG store for later rag_search."""
+    logger.debug(f"Entered into rag_ingest: path={path}, recursive={recursive}")
+    from elidia.rag.ingest import FileIngestPipeline
+
+    target = Path(path)
+
+    async def _run() -> None:
+        engine = await _open_rag_engine()
+        pipeline = FileIngestPipeline(engine)
+        try:
+            if target.is_dir():
+                console.print(f"[cyan]Ingesting directory:[/cyan] {target}")
+                result = await pipeline.ingest_directory(target, recursive=recursive)
+                console.print(
+                    f"[green]v[/green] Ingested {result['files']} file(s), "
+                    f"{result['chunks']} chunk(s), skipped {result['skipped']}"
+                )
+            else:
+                console.print(f"[cyan]Ingesting file:[/cyan] {target}")
+                ids = await pipeline.ingest_file(target)
+                if ids:
+                    console.print(f"[green]v[/green] Ingested {len(ids)} chunk(s) from {target.name}")
+                else:
+                    console.print(
+                        f"[yellow]Nothing ingested from {target.name}[/yellow] "
+                        "(unsupported type, empty, too large, or already ingested — same content hash)"
+                    )
+        finally:
+            engine.close()
+
+    asyncio.run(_run())
+
+
+@rag.command("search")
+@click.argument("query")
+@click.option("--limit", default=5, type=int, help="Max results")
+def rag_search_cmd(query: str, limit: int) -> None:
+    """Search the local RAG store."""
+    logger.debug(f"Entered into rag_search_cmd: query={query!r}, limit={limit}")
+
+    async def _run() -> None:
+        engine = await _open_rag_engine()
+        try:
+            results = await engine.search(query, limit=limit)
+            if not results:
+                console.print("[yellow]No matching content found.[/yellow]")
+                return
+            for r in results:
+                doc = r.document
+                console.print(
+                    f"\n[cyan]{doc.source}[/cyan] "
+                    f"[dim](chunk {doc.chunk_index + 1}/{doc.total_chunks}, score={r.score:.3f})[/dim]"
+                )
+                console.print(doc.content[:500] + ("..." if len(doc.content) > 500 else ""))
+        finally:
+            engine.close()
+
+    asyncio.run(_run())
+
+
+@rag.command("list")
+def rag_list() -> None:
+    """Show how much content is currently ingested."""
+    logger.debug("Entered into rag_list")
+
+    async def _run() -> None:
+        engine = await _open_rag_engine()
+        try:
+            counts = engine.count_documents()
+            if counts["sources"] == 0:
+                console.print("[yellow]Nothing has been ingested yet.[/yellow] Run: elidia rag ingest <path>")
+            else:
+                console.print(f"{counts['sources']} source(s), {counts['chunks']} chunk(s) ingested.")
+        finally:
+            engine.close()
+
+    asyncio.run(_run())
+
+
+@rag.command("clear")
+@click.option("--source", default=None, help="Only clear entries from this source path (default: clear everything)")
+@click.confirmation_option(prompt="This permanently deletes ingested RAG data. Continue?")
+def rag_clear(source: str | None) -> None:
+    """Delete ingested content from the local RAG store."""
+    logger.debug(f"Entered into rag_clear: source={source}")
+
+    async def _run() -> None:
+        engine = await _open_rag_engine()
+        try:
+            if source:
+                n = engine.delete_source(source)
+                console.print(f"[green]v[/green] Deleted {n} chunk(s) from {source}")
+            else:
+                n = engine.clear_all()
+                console.print(f"[green]v[/green] Deleted {n} chunk(s) — RAG store is now empty")
+        finally:
+            engine.close()
+
+    asyncio.run(_run())