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

elidia_agent_cli-0.3.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.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elidia-agent-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Elidia Agent CLI — Universal AI Agent for your terminal
 Author-email: Elidia Technology Pvt Ltd <support@aiutils.io>
 License-Expression: LicenseRef-Proprietary

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.3.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.3.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.3.0}/elidia/agent/loop.py

@@ -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.3.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.3.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)
@@ -643,3 +701,135 @@ def workflow_run(path: str) -> None:
                 await client.close()
 
     asyncio.run(_run())
+
+
+# --- 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())

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.3.0}/elidia/cli/repl.py

@@ -242,8 +242,10 @@ class ElidiaRepl:
         logger.debug("Entered into cleanup")
         from elidia.tools.browser import close_browser_session
         from elidia.tools.database import close_database_session
+        from elidia.tools.rag import close_rag_session
         await close_browser_session()
         close_database_session()
+        close_rag_session()
         if self._daemon:
             await self._daemon.stop()
         if self._mcp_registry:
@@ -386,6 +388,8 @@ class ElidiaRepl:
             return self._cmd_pager(arg)
         if cmd == "image":
             return await self._cmd_image(arg)
+        if cmd == "rag":
+            return await self._cmd_rag(arg)
         if cmd in ("quit", "exit"):
             raise EOFError()
 
@@ -471,8 +475,10 @@ class ElidiaRepl:
     def _cmd_new(self) -> bool:
         from elidia.tools.browser import close_browser_session
         from elidia.tools.database import close_database_session
+        from elidia.tools.rag import close_rag_session
         asyncio.ensure_future(close_browser_session())
         close_database_session()
+        close_rag_session()
 
         # Compact current session before starting a new one
         if self._compactor and len(self._messages) >= 4:
@@ -934,6 +940,69 @@ class ElidiaRepl:
 
         return True
 
+    async def _cmd_rag(self, arg: str) -> bool:
+        logger.debug(f"Entered into _cmd_rag: arg={arg}")
+        from elidia.tools.rag import _get_session
+
+        parts = arg.split(maxsplit=1)
+        action = parts[0] if parts else ""
+        rest = parts[1] if len(parts) > 1 else ""
+
+        if action == "ingest" and rest:
+            from pathlib import Path as _Path
+
+            from elidia.rag.ingest import FileIngestPipeline
+            from elidia.tools.rag import _ensure_engine
+
+            target = _Path(rest).expanduser()
+            if not target.exists():
+                self._console.print(f"[red]Path not found: {rest}[/red]")
+                return True
+            try:
+                engine = await _ensure_engine()
+            except RuntimeError as e:
+                self._console.print(f"[red]{e}[/red]")
+                return True
+            pipeline = FileIngestPipeline(engine)
+            if target.is_dir():
+                self._console.print(f"[cyan]Ingesting directory:[/cyan] {target}")
+                result = await pipeline.ingest_directory(target)
+                self._console.print(
+                    f"[green]v[/green] Ingested {result['files']} file(s), "
+                    f"{result['chunks']} chunk(s), skipped {result['skipped']}"
+                )
+            else:
+                ids = await pipeline.ingest_file(target)
+                if ids:
+                    self._console.print(f"[green]v[/green] Ingested {len(ids)} chunk(s) from {target.name}")
+                else:
+                    self._console.print(f"[yellow]Nothing ingested from {target.name}[/yellow]")
+            return True
+
+        if action == "search" and rest:
+            from elidia.tools.rag import _rag_search
+            result = await _rag_search(rest, limit=5)
+            self._console.print(result.content)
+            return True
+
+        if action == "list" or (not action and not arg):
+            from elidia.tools.rag import _rag_list_sources
+            result = await _rag_list_sources()
+            self._console.print(result.content)
+            return True
+
+        if action == "clear":
+            session = _get_session()
+            if session.engine is not None:
+                n = session.engine.clear_all()
+                self._console.print(f"[green]v[/green] Deleted {n} chunk(s) — RAG store is now empty")
+            else:
+                self._console.print("[dim]RAG store not open this session.[/dim]")
+            return True
+
+        self._console.print("[yellow]Usage: /rag [ingest <path>|search <query>|list|clear][/yellow]")
+        return True
+
     async def _cmd_daemon(self, arg: str) -> bool:
         logger.debug(f"Entered into _cmd_daemon: arg={arg}")
         if not self._daemon:

{elidia_agent_cli-0.2.0 → elidia_agent_cli-0.3.0}/elidia/permissions/manager.py

@@ -30,6 +30,7 @@ ACTION_TIERS: dict[str, PermissionTier] = {
     "clipboard_read": PermissionTier.AUTO,
     "mcp_call_auto": PermissionTier.AUTO,
     "browser_read": PermissionTier.AUTO,
+    "rag_search": PermissionTier.AUTO,
 
     "file_write_project": PermissionTier.SESSION,
     "command_exec": PermissionTier.SESSION,