gemini-cli-pro 0.0.6-snapshot → 0.0.8-snapshot

package/README.md

@@ -52,5 +52,5 @@ Comandos do chat:
 
 O arquivo `~/.cache/gemini-history-chats/config.json` controla os MCPs (`local_rag`, `github`, `memory`).
 Se algum MCP nao estiver disponivel, o CLI continua funcionando no modo API.
-O MCP local de RAG usa `own-rag-cli` como nativo e cai para `own-rag` se existir.
+O MCP local de RAG usa `rag-codebase` via comando `mcp-rag-server` quando estiver instalado.
 Em toda nova sessao, os MCPs sao recarregados automaticamente no startup.

package/gemini_tool.py

@@ -15,14 +15,37 @@ from typing import Any, Callable
 
 import google.generativeai as genai
 
+try:
+    import readline
+except ImportError:  # pragma: no cover
+    readline = None  # type: ignore[assignment]
+
 CACHE_DIR = Path.home() / ".cache" / "gemini-history-chats"
 CONFIG_PATH = CACHE_DIR / "config.json"
 MEMORY_PATH = CACHE_DIR / "memory_store.json"
 
 MODEL_FLASH = "gemini-2.5-flash"
 MODEL_PRO = "gemini-2.5-pro"
-RAG_NATIVE_COMMAND = "own-rag-cli"
-RAG_FALLBACK_COMMAND = "own-rag"
+RAG_SERVER_COMMAND = "mcp-rag-server"
+
+ANSI_RESET = "\033[0m"
+ANSI_BOLD = "\033[1m"
+ANSI_DIM = "\033[2m"
+ANSI_CYAN = "\033[96m"
+ANSI_BLUE = "\033[94m"
+ANSI_GREEN = "\033[92m"
+ANSI_YELLOW = "\033[93m"
+ANSI_RED = "\033[91m"
+ANSI_MAGENTA = "\033[95m"
+ANSI_WHITE = "\033[97m"
+
+
+def colorize(text: str, color: str) -> str:
+    return f"{color}{text}{ANSI_RESET}"
+
+
+def command_history_path_for_cwd() -> Path:
+    return CACHE_DIR / f"{get_project_hash()}.cmd_history"
 
 
 def ensure_cache_layout() -> None:
@@ -34,9 +57,9 @@ def ensure_cache_layout() -> None:
         "mcps": {
             "local_rag": {
                 "enabled": True,
-                "transport": "cli",
-                "command": RAG_NATIVE_COMMAND,
-                "description": "Local RAG via own-rag-cli (fallback own-rag)",
+                "transport": "mcp-stdio",
+                "server_command": RAG_SERVER_COMMAND,
+                "description": "Local RAG via servidor MCP rag-codebase",
             },
             "github": {
                 "enabled": True,
@@ -85,7 +108,7 @@ def merge_dict(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]
 def require_api_key() -> str:
     api_key = os.getenv("GOOGLE_API_KEY")
     if not api_key:
-        print("Erro: defina GOOGLE_API_KEY antes de iniciar.", file=sys.stderr)
+        print(colorize("Erro: defina GOOGLE_API_KEY antes de iniciar.", ANSI_RED), file=sys.stderr)
         sys.exit(1)
     return api_key
 
@@ -200,67 +223,103 @@ def emit_plin() -> None:
     print("\a", end="", flush=True)
 
 
-def _config_rag_candidates(config: dict[str, Any]) -> list[str]:
-    candidates: list[str] = [RAG_NATIVE_COMMAND]
+def _config_rag_server_candidates(config: dict[str, Any]) -> list[str]:
+    candidates: list[str] = [RAG_SERVER_COMMAND]
     mcps = config.get("mcps", {})
     if isinstance(mcps, dict):
         local_rag = mcps.get("local_rag", {})
         if isinstance(local_rag, dict):
-            configured = local_rag.get("command")
+            configured = local_rag.get("server_command")
             if isinstance(configured, str) and configured.strip():
-                candidates.append(configured.strip())
+                candidates.insert(0, configured.strip())
             if isinstance(configured, list):
                 for item in configured:
                     if isinstance(item, str) and item.strip():
-                        candidates.append(item.strip())
-    candidates.append(RAG_FALLBACK_COMMAND)
-    # remove duplicados preservando ordem
+                        candidates.insert(0, item.strip())
     return list(dict.fromkeys(candidates))
 
 
-def resolve_rag_command(config: dict[str, Any] | None = None) -> str | None:
+def resolve_rag_server_command(config: dict[str, Any] | None = None) -> str | None:
     effective_config = config if isinstance(config, dict) else load_config()
-    for candidate in _config_rag_candidates(effective_config):
+    for candidate in _config_rag_server_candidates(effective_config):
         if shutil.which(candidate):
             return candidate
     return None
 
 
-def check_own_rag_installed(config: dict[str, Any] | None = None) -> bool:
-    return resolve_rag_command(config) is not None
+def check_rag_server_available(config: dict[str, Any] | None = None) -> bool:
+    return resolve_rag_server_command(config) is not None
 
 
 def rag_sync_current_dir(config: dict[str, Any] | None = None) -> tuple[bool, str]:
-    rag_command = resolve_rag_command(config)
-    if not rag_command:
-        return False, "MISSING"
+    if resolve_rag_server_command(config):
+        # Com MCP rag-codebase disponível, considera backend RAG pronto.
+        return True, "OK"
+    return False, "OFF"
+
+
+def _python_for_script(script_path: str) -> str:
+    try:
+        with open(script_path, "r", encoding="utf-8") as handle:
+            first_line = handle.readline().strip()
+        if first_line.startswith("#!") and "python" in first_line:
+            return first_line[2:].strip()
+    except Exception:
+        pass
+    return sys.executable
+
+
+def search_local_context_via_rag_server(query: str) -> str:
+    server_command = resolve_rag_server_command()
+    if not server_command:
+        return ""
+
+    server_path = shutil.which(server_command)
+    if not server_path:
+        return ""
 
-    result = _run_command([rag_command, "sync", "."])
+    runner_code = r'''
+import importlib.util
+import pathlib
+import sys
+
+server_file = pathlib.Path(sys.argv[1]).expanduser().resolve()
+query = sys.argv[2]
+top_k = int(sys.argv[3])
+mode = sys.argv[4]
+
+spec = importlib.util.spec_from_file_location("mcp_rag_server_runtime", server_file)
+if spec is None or spec.loader is None:
+    raise RuntimeError("falha ao carregar modulo do mcp-rag-server")
+mod = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mod)
+
+if not hasattr(mod, "semantic_search_code"):
+    raise RuntimeError("semantic_search_code nao encontrado no mcp-rag-server")
+
+result = mod.semantic_search_code(query=query, top_k=top_k, mode=mode)
+print(result if isinstance(result, str) else str(result))
+'''
+
+    py_exec = _python_for_script(server_path)
+    result = _run_command([py_exec, "-c", runner_code, server_path, query, "6", "single"], timeout=180)
+    stdout = (result.stdout or "").strip()
+    stderr = (result.stderr or "").strip()
     if result.returncode == 0:
-        return True, "OK"
-    return False, "FAIL"
+        return stdout or "Nenhum resultado no rag-codebase."
+    return f"Erro no rag-codebase (code={result.returncode}): {stderr or stdout or 'sem detalhes'}"
 
 
 def search_local_context(query: str) -> str:
-    """Busca no contexto local usando own-rag search."""
-    rag_command = resolve_rag_command()
-    if not rag_command:
-        return "own-rag-cli/own-rag nao encontrado no PATH."
+    """Busca no contexto local usando o servidor MCP rag-codebase."""
+    server_command = resolve_rag_server_command()
+    if not server_command:
+        return ""
 
     query = (query or "").strip()
     if not query:
         return "Consulta vazia."
-
-    result = _run_command([rag_command, "search", query])
-    stdout = (result.stdout or "").strip()
-    stderr = (result.stderr or "").strip()
-
-    if result.returncode == 0:
-        return stdout or "Nenhum resultado no RAG local."
-    return (
-        f"Erro no {rag_command} search (code={result.returncode}): "
-        f"{stderr or stdout or 'sem detalhes'}"
-    )
+    return search_local_context_via_rag_server(query)
 
 
 def github_tool(action: str, repo: str, path: str = "") -> str:
@@ -356,7 +415,7 @@ def _mcp_enabled(config: dict[str, Any], mcp_name: str, default: bool = True) ->
 
 def build_tools(config: dict[str, Any]) -> list[Any]:
     tools: list[Any] = []
-    if _mcp_enabled(config, "local_rag", default=True) and check_own_rag_installed(config):
+    if _mcp_enabled(config, "local_rag", default=True) and check_rag_server_available(config):
         tools.append(as_executable(search_local_context))
     if _mcp_enabled(config, "github", default=True):
         tools.append(as_executable(github_tool))
@@ -383,14 +442,66 @@ class GeminiToolCLI:
         self.tools_active = False
         self.tools_error = ""
         self.rag_command: str | None = None
+        self.rag_server_found = False
         self.rag_ok = False
         self.rag_status = "MISSING"
+        self.command_history_file = command_history_path_for_cwd()
+        self.readline_enabled = False
 
         self.reload_mcps(sync_rag=True, announce=False)
+        self._init_readline()
 
         self.model = self._build_model(self.current_model_name)
         self.chat = self.model.start_chat(history=self.history)
 
+    def _init_readline(self) -> None:
+        if readline is None or not sys.stdin.isatty():
+            return
+        try:
+            readline.parse_and_bind("set editing-mode emacs")
+            readline.parse_and_bind('"\\e[A": previous-history')
+            readline.parse_and_bind('"\\e[B": next-history')
+            readline.parse_and_bind('"\\e[C": forward-char')
+            readline.parse_and_bind('"\\e[D": backward-char')
+            readline.set_history_length(1000)
+            if self.command_history_file.exists():
+                readline.read_history_file(str(self.command_history_file))
+            self.readline_enabled = True
+        except Exception:
+            self.readline_enabled = False
+
+    def _save_command_history(self) -> None:
+        if readline is None or not self.readline_enabled:
+            return
+        try:
+            readline.write_history_file(str(self.command_history_file))
+        except Exception:
+            pass
+
+    def _record_command_history(self, value: str) -> None:
+        if readline is None or not self.readline_enabled:
+            return
+        text = (value or "").strip()
+        if not text:
+            return
+        last_len = readline.get_current_history_length()
+        if last_len > 0 and readline.get_history_item(last_len) == text:
+            return
+        readline.add_history(text)
+        self._save_command_history()
+
+    def _print_info(self, message: str) -> None:
+        print(colorize(message, ANSI_BLUE))
+
+    def _print_success(self, message: str) -> None:
+        print(colorize(message, ANSI_GREEN))
+
+    def _print_warn(self, message: str) -> None:
+        print(colorize(message, ANSI_YELLOW))
+
+    def _print_error(self, message: str) -> None:
+        print(colorize(message, ANSI_RED))
+
     def _build_model(self, model_name: str) -> genai.GenerativeModel:
         if not self.tools:
             return genai.GenerativeModel(model_name=model_name)
@@ -408,7 +519,20 @@ class GeminiToolCLI:
         return "FLASH"
 
     def _prompt(self) -> str:
-        return f"[{self._prompt_model_tag()}][RAG:{self.rag_status}] >> "
+        model_tag = colorize(self._prompt_model_tag(), ANSI_MAGENTA)
+        rag_tag = colorize(self.rag_status, ANSI_GREEN if self.rag_status == "OK" else ANSI_YELLOW)
+        arrow = f"{ANSI_CYAN}>> {ANSI_WHITE}"
+        return f"[{model_tag}][RAG:{rag_tag}] {arrow}"
+
+    def _read_user_input(self) -> str:
+        prompt_text = self._prompt()
+        if not sys.stdin.isatty():
+            return input(prompt_text).strip()
+        print(prompt_text, end="", flush=True)
+        try:
+            return input().strip()
+        finally:
+            print(ANSI_RESET, end="", flush=True)
 
     def _switch_model_if_needed(self, model_name: str) -> None:
         if model_name == self.current_model_name:
@@ -480,28 +604,36 @@ class GeminiToolCLI:
         self.history.append({"role": role, "parts": [text]})
 
     def _print_help(self) -> None:
-        print("Comandos: /auto, /pro, /flash, /sync, /reload-mcps, /status, /help, /exit")
+        self._print_info("Comandos: /auto, /pro, /flash, /sync, /reload-mcps, /status, /help, /exit")
 
     def _show_status(self) -> None:
         tools_state = "ON" if self.tools_active else "OFF"
         rag_cmd = self.rag_command or "none"
         print(
-            f"mode={self.mode} model={self._prompt_model_tag()} rag={self.rag_status} "
-            f"rag_cmd={rag_cmd} tools={tools_state} history={history_path_for_cwd()}"
+            colorize(
+                f"mode={self.mode} model={self._prompt_model_tag()} rag={self.rag_status} "
+                f"rag_cmd={rag_cmd} tools={tools_state} history={history_path_for_cwd()}",
+                ANSI_DIM,
+            )
         )
         if self.tools_error:
-            print(f"tools_error={self.tools_error}")
+            self._print_warn(f"tools_error={self.tools_error}")
 
     def _resync_rag(self) -> None:
         rag_ok, rag_status = rag_sync_current_dir(self.config)
         self.rag_ok = rag_ok
         self.rag_status = rag_status
-        print(f"RAG sync status: {self.rag_status}")
+        if self.rag_ok:
+            self._print_success(f"RAG sync status: {self.rag_status}")
+        else:
+            self._print_warn(f"RAG sync status: {self.rag_status}")
 
     def reload_mcps(self, sync_rag: bool = True, announce: bool = True) -> None:
         """Recarrega MCPs/config no inicio da sessao e sob comando manual."""
         self.config = load_config()
-        self.rag_command = resolve_rag_command(self.config)
+        rag_server_command = resolve_rag_server_command(self.config)
+        self.rag_command = rag_server_command
+        self.rag_server_found = rag_server_command is not None
         self.tools = build_tools(self.config)
         self.tools_active = bool(self.tools)
         self.tools_error = ""
@@ -518,35 +650,32 @@ class GeminiToolCLI:
 
         if announce:
             rag_info = self.rag_command or "indisponivel"
-            print(
+            self._print_info(
                 f"MCPs recarregados. tools={'ON' if self.tools_active else 'OFF'} "
                 f"rag={self.rag_status} cmd={rag_info}"
             )
 
     def run(self) -> int:
-        print(f"Gemini Tool iniciado em: {os.path.abspath(os.getcwd())}")
-        print(f"Historico: {history_path_for_cwd()}")
-
-        if not self.rag_ok:
-            print(
-                "Aviso: RAG nao esta OK. Use /sync para tentar novamente ",
-                "(ou instale own-rag-cli/own-rag).",
-            )
+        self._print_info(f"{ANSI_BOLD}Gemini Tool iniciado em:{ANSI_RESET} {os.path.abspath(os.getcwd())}")
+        print(colorize(f"Historico: {history_path_for_cwd()}", ANSI_DIM))
+        if self.rag_server_found:
+            self._print_success("Servidor rag-codebase encontrado. Vou utiliza-lo nesta sessao.")
 
         self._print_help()
 
         while True:
             try:
-                raw = input(self._prompt()).strip()
+                raw = self._read_user_input()
             except EOFError:
                 print()
                 break
             except KeyboardInterrupt:
-                print("\nInterrompido.")
+                self._print_warn("Interrompido.")
                 break
 
             if not raw:
                 continue
+            self._record_command_history(raw)
 
             if raw in {"/exit", "/quit", "sair"}:
                 break
@@ -564,17 +693,17 @@ class GeminiToolCLI:
                 continue
             if raw == "/auto":
                 self.mode = "AUTO"
-                print("Modo alterado para AUTO")
+                self._print_info("Modo alterado para AUTO")
                 continue
             if raw == "/pro":
                 self.mode = "PRO"
                 self._switch_model_if_needed(MODEL_PRO)
-                print("Modo alterado para PRO")
+                self._print_info("Modo alterado para PRO")
                 continue
             if raw == "/flash":
                 self.mode = "FLASH"
                 self._switch_model_if_needed(MODEL_FLASH)
-                print("Modo alterado para FLASH")
+                self._print_info("Modo alterado para FLASH")
                 continue
 
             decision = self.route_for_input(raw)
@@ -585,15 +714,16 @@ class GeminiToolCLI:
             full_response = ""
             try:
                 stream = self.chat.send_message(raw, stream=True)
+                print(ANSI_CYAN, end="")
                 for chunk in stream:
                     piece = self._extract_text(chunk)
                     if piece:
                         full_response += piece
                         print(piece, end="", flush=True)
-                print()
+                print(ANSI_RESET)
                 emit_plin()
             except Exception as exc:
-                print(f"Erro ao gerar resposta: {exc}")
+                self._print_error(f"Erro ao gerar resposta: {exc}")
                 self.history.pop()
                 emit_plin()
                 continue
@@ -602,6 +732,7 @@ class GeminiToolCLI:
             save_history(self.history)
 
         save_history(self.history)
+        self._save_command_history()
         return 0
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemini-cli-pro",
-  "version": "0.0.6-snapshot",
+  "version": "0.0.8-snapshot",
   "description": "Gemini CLI em Python com sync de RAG local e roteamento Flash/Pro",
   "license": "MIT",
   "bin": {