gemini-cli-pro 0.0.3-snapshot

package/README.md

@@ -0,0 +1,56 @@
+# Gemini CLI
+
+CLI em Python para automacao de codificacao com Gemini, roteamento dinamico Flash/Pro e sincronizacao de RAG local.
+
+## Requisitos
+
+- Node.js 18+
+- Python 3.10+
+- `GOOGLE_API_KEY` configurada
+- Dependencia Python: `google-generativeai`
+
+## Instalacao global (npm)
+
+Opcao direta:
+
+```bash
+npm install -g gemini-cli-pro
+```
+
+Com fallback automatico para `gemini-cli`:
+
+```bash
+npm run install:global
+```
+
+## Publicacao no npm
+
+Antes de publicar, o script garante o nome:
+- `gemini-cli-pro`
+
+```bash
+npm run publish:npm
+```
+
+## Execucao
+
+```bash
+gemini
+```
+
+Comandos do chat:
+- `/auto`
+- `/pro`
+- `/flash`
+- `/sync`
+- `/reload-mcps`
+- `/status`
+- `/help`
+- `/exit`
+
+## MCPs opcionais
+
+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.
+Em toda nova sessao, os MCPs sao recarregados automaticamente no startup.

package/bin/gemini

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+PYTHON_BIN="${PYTHON_BIN:-python3}"
+
+if ! command -v "${PYTHON_BIN}" >/dev/null 2>&1; then
+  echo "Erro: python3 nao encontrado no PATH." >&2
+  exit 1
+fi
+
+if ! "${PYTHON_BIN}" -c "import google.generativeai" >/dev/null 2>&1; then
+  echo "Dependencia ausente: google-generativeai" >&2
+  echo "Instale com: python3 -m pip install --upgrade google-generativeai" >&2
+  exit 1
+fi
+
+exec "${PYTHON_BIN}" "${PROJECT_DIR}/gemini_tool.py" "$@"

package/gemini_tool.py

@@ -0,0 +1,623 @@
+#!/usr/bin/env python3
+"""Gemini CLI com automacao de codificacao e RAG dinamico."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+import google.generativeai as genai
+
+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"
+
+
+def ensure_cache_layout() -> None:
+    """Cria estrutura centralizada de cache e configuracao de MCPs."""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    default_config = {
+        "version": 1,
+        "mcps": {
+            "local_rag": {
+                "enabled": True,
+                "transport": "cli",
+                "command": RAG_NATIVE_COMMAND,
+                "description": "Local RAG via own-rag-cli (fallback own-rag)",
+            },
+            "github": {
+                "enabled": True,
+                "transport": "simulated",
+                "description": "GitHub MCP mock adapter",
+            },
+            "memory": {
+                "enabled": True,
+                "transport": "local-file",
+                "file": str(MEMORY_PATH),
+                "description": "Memory MCP mock adapter",
+            },
+        },
+    }
+
+    if CONFIG_PATH.exists():
+        try:
+            data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            data = {}
+        merged = merge_dict(default_config, data)
+        CONFIG_PATH.write_text(
+            json.dumps(merged, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+    else:
+        CONFIG_PATH.write_text(
+            json.dumps(default_config, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+
+    if not MEMORY_PATH.exists():
+        MEMORY_PATH.write_text("{}\n", encoding="utf-8")
+
+
+def merge_dict(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    result = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(result.get(key), dict):
+            result[key] = merge_dict(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+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)
+        sys.exit(1)
+    return api_key
+
+
+def load_config() -> dict[str, Any]:
+    try:
+        data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+    if isinstance(data, dict):
+        return data
+    return {}
+
+
+def get_project_hash() -> str:
+    project_path = os.path.abspath(os.getcwd())
+    return hashlib.sha256(project_path.encode("utf-8")).hexdigest()
+
+
+def history_path_for_cwd() -> Path:
+    return CACHE_DIR / f"{get_project_hash()}.json"
+
+
+def load_history() -> list[dict[str, Any]]:
+    path = history_path_for_cwd()
+    if not path.exists():
+        return []
+
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return []
+
+    if not isinstance(data, list):
+        return []
+
+    cleaned: list[dict[str, Any]] = []
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        role = item.get("role")
+        parts = item.get("parts")
+        if role in {"user", "model"} and isinstance(parts, list):
+            cleaned.append({"role": role, "parts": [str(p) for p in parts]})
+    return cleaned
+
+
+def save_history(history: list[dict[str, Any]]) -> None:
+    path = history_path_for_cwd()
+    path.write_text(
+        json.dumps(history, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+
+def load_memory_store() -> dict[str, str]:
+    try:
+        data = json.loads(MEMORY_PATH.read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+    if not isinstance(data, dict):
+        return {}
+
+    return {str(k): str(v) for k, v in data.items()}
+
+
+def save_memory_store(data: dict[str, str]) -> None:
+    MEMORY_PATH.write_text(
+        json.dumps(data, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+
+def _run_command(cmd: list[str], timeout: int = 90) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=False,
+    )
+
+
+def emit_plin() -> None:
+    """Toca um alerta sonoro curto usando o som padrao do Ubuntu (com fallback)."""
+    sound_candidates = [
+        "/usr/share/sounds/ubuntu/stereo/message.ogg",
+        "/usr/share/sounds/freedesktop/stereo/complete.oga",
+    ]
+
+    for sound in sound_candidates:
+        if not Path(sound).exists():
+            continue
+        if shutil.which("paplay"):
+            subprocess.Popen(  # noqa: S603
+                ["paplay", sound],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            return
+
+    if shutil.which("canberra-gtk-play"):
+        subprocess.Popen(  # noqa: S603
+            ["canberra-gtk-play", "-i", "message"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return
+
+    # Fallback para terminal bell.
+    print("\a", end="", flush=True)
+
+
+def _config_rag_candidates(config: dict[str, Any]) -> list[str]:
+    candidates: list[str] = [RAG_NATIVE_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")
+            if isinstance(configured, str) and configured.strip():
+                candidates.append(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
+    return list(dict.fromkeys(candidates))
+
+
+def resolve_rag_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):
+        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 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"
+
+    result = _run_command([rag_command, "sync", "."])
+    if result.returncode == 0:
+        return True, "OK"
+    return False, "FAIL"
+
+
+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."
+
+    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'}"
+    )
+
+
+def github_tool(action: str, repo: str, path: str = "") -> str:
+    """Simula um MCP de GitHub para automacoes."""
+    action = (action or "").strip().lower()
+    repo = (repo or "").strip()
+    path = (path or "").strip()
+
+    if not action or not repo:
+        return "github_tool: informe action e repo."
+
+    simulated_payload = {
+        "mcp": "github",
+        "mode": "simulated",
+        "action": action,
+        "repo": repo,
+        "path": path,
+        "status": "ok",
+        "hint": "Integre aqui chamadas reais ao MCP de GitHub quando necessario.",
+    }
+    return json.dumps(simulated_payload, ensure_ascii=False)
+
+
+def memory_tool(action: str, key: str, value: str = "") -> str:
+    """Simula Memory MCP persistindo fatos entre sessoes."""
+    action = (action or "").strip().lower()
+    key = (key or "").strip()
+    value = (value or "").strip()
+
+    store = load_memory_store()
+
+    if action in {"set", "save", "upsert"}:
+        if not key:
+            return "memory_tool(set): informe key."
+        store[key] = value
+        save_memory_store(store)
+        return f"memory_tool: salvo '{key}'."
+
+    if action in {"get", "read"}:
+        if not key:
+            return "memory_tool(get): informe key."
+        return store.get(key, "") or f"memory_tool: chave '{key}' nao encontrada."
+
+    if action in {"delete", "del", "remove"}:
+        if not key:
+            return "memory_tool(delete): informe key."
+        existed = key in store
+        store.pop(key, None)
+        save_memory_store(store)
+        return "memory_tool: chave removida." if existed else "memory_tool: chave nao existia."
+
+    if action in {"list", "keys"}:
+        keys = sorted(store.keys())
+        return json.dumps({"keys": keys}, ensure_ascii=False)
+
+    return "memory_tool: action invalida. Use set/get/delete/list."
+
+
+def as_executable(func: Callable[..., str]) -> Any:
+    """Registra ferramenta como genai.Executable quando disponivel."""
+    executable_cls = getattr(genai, "Executable", None)
+    if executable_cls is None:
+        return func
+
+    # Compatibilidade com variantes de construtor.
+    constructors: list[Callable[[], Any]] = [lambda: executable_cls(func)]
+    if hasattr(executable_cls, "from_function"):
+        constructors.append(lambda: executable_cls.from_function(func))
+    if hasattr(executable_cls, "from_callable"):
+        constructors.append(lambda: executable_cls.from_callable(func))
+
+    for build in constructors:
+        try:
+            built = build()
+            if built is not None:
+                return built
+        except Exception:
+            continue
+
+    return func
+
+
+def _mcp_enabled(config: dict[str, Any], mcp_name: str, default: bool = True) -> bool:
+    mcps = config.get("mcps", {})
+    if not isinstance(mcps, dict):
+        return default
+    mcp_cfg = mcps.get(mcp_name, {})
+    if not isinstance(mcp_cfg, dict):
+        return default
+    enabled = mcp_cfg.get("enabled", default)
+    return bool(enabled)
+
+
+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):
+        tools.append(as_executable(search_local_context))
+    if _mcp_enabled(config, "github", default=True):
+        tools.append(as_executable(github_tool))
+    if _mcp_enabled(config, "memory", default=True):
+        tools.append(as_executable(memory_tool))
+    return tools
+
+
+@dataclass
+class RouteDecision:
+    model_name: str
+    reason: str
+
+
+class GeminiToolCLI:
+    def __init__(self) -> None:
+        ensure_cache_layout()
+        genai.configure(api_key=require_api_key())
+        self.mode = "AUTO"
+        self.current_model_name = MODEL_FLASH
+        self.history = load_history()
+        self.config: dict[str, Any] = {}
+        self.tools: list[Any] = []
+        self.tools_active = False
+        self.tools_error = ""
+        self.rag_command: str | None = None
+        self.rag_ok = False
+        self.rag_status = "MISSING"
+
+        self.reload_mcps(sync_rag=True, announce=False)
+
+        self.model = self._build_model(self.current_model_name)
+        self.chat = self.model.start_chat(history=self.history)
+
+    def _build_model(self, model_name: str) -> genai.GenerativeModel:
+        if not self.tools:
+            return genai.GenerativeModel(model_name=model_name)
+        try:
+            return genai.GenerativeModel(model_name=model_name, tools=self.tools)
+        except Exception as exc:
+            # Se o SDK nao suportar/aceitar tools no ambiente atual, segue sem MCP.
+            self.tools_active = False
+            self.tools_error = str(exc)
+            return genai.GenerativeModel(model_name=model_name)
+
+    def _prompt_model_tag(self) -> str:
+        if self.current_model_name == MODEL_PRO:
+            return "PRO"
+        return "FLASH"
+
+    def _prompt(self) -> str:
+        return f"[{self._prompt_model_tag()}][RAG:{self.rag_status}] >> "
+
+    def _switch_model_if_needed(self, model_name: str) -> None:
+        if model_name == self.current_model_name:
+            return
+        self.current_model_name = model_name
+        self.model = self._build_model(model_name)
+        self.chat = self.model.start_chat(history=self.history)
+
+    def _heuristic_route(self, user_text: str) -> RouteDecision:
+        normalized = (user_text or "").lower()
+        pro_keywords = [
+            "cria",
+            "criar",
+            "criacao",
+            "criação",
+            "refatora",
+            "refatoracao",
+            "refatoração",
+            "analisar bug",
+            "analise de bug",
+            "análise de bug",
+            "debug",
+            "arquitetura",
+            "complex",
+            "complexa",
+        ]
+        if any(keyword in normalized for keyword in pro_keywords):
+            return RouteDecision(MODEL_PRO, "heuristica: tarefa potencialmente complexa")
+        return RouteDecision(MODEL_FLASH, "heuristica: tarefa comum")
+
+    def _flash_router(self, user_text: str) -> RouteDecision:
+        """No modo /auto, usa Flash para decidir FLASH vs PRO."""
+        router_prompt = (
+            "Voce e um roteador de modelos.\n"
+            "Classifique a tarefa do usuario em apenas UMA palavra: PRO ou FLASH.\n"
+            "Use PRO quando envolver criacao extensa, refatoracao complexa, analise profunda de bugs,"
+            "ou design arquitetural.\n"
+            "Caso contrario, use FLASH.\n"
+            f"Tarefa: {user_text}"
+        )
+
+        try:
+            router = genai.GenerativeModel(model_name=MODEL_FLASH)
+            response = router.generate_content(router_prompt)
+            answer = ((response.text if hasattr(response, "text") else "") or "").upper()
+            if "PRO" in answer:
+                return RouteDecision(MODEL_PRO, "router flash")
+            if "FLASH" in answer:
+                return RouteDecision(MODEL_FLASH, "router flash")
+        except Exception:
+            pass
+
+        return self._heuristic_route(user_text)
+
+    def route_for_input(self, user_text: str) -> RouteDecision:
+        if self.mode == "PRO":
+            return RouteDecision(MODEL_PRO, "modo travado /pro")
+        if self.mode == "FLASH":
+            return RouteDecision(MODEL_FLASH, "modo travado /flash")
+        return self._flash_router(user_text)
+
+    def _extract_text(self, chunk: Any) -> str:
+        text = getattr(chunk, "text", None)
+        if isinstance(text, str):
+            return text
+        return ""
+
+    def _append_to_history(self, role: str, text: str) -> None:
+        self.history.append({"role": role, "parts": [text]})
+
+    def _print_help(self) -> None:
+        print("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()}"
+        )
+        if self.tools_error:
+            print(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}")
+
+    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)
+        self.tools = build_tools(self.config)
+        self.tools_active = bool(self.tools)
+        self.tools_error = ""
+
+        if sync_rag:
+            self.rag_ok, self.rag_status = rag_sync_current_dir(self.config)
+        else:
+            self.rag_ok = bool(self.rag_command)
+            self.rag_status = "OK" if self.rag_ok else "MISSING"
+
+        if hasattr(self, "model") and hasattr(self, "chat"):
+            self.model = self._build_model(self.current_model_name)
+            self.chat = self.model.start_chat(history=self.history)
+
+        if announce:
+            rag_info = self.rag_command or "indisponivel"
+            print(
+                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_help()
+
+        while True:
+            try:
+                raw = input(self._prompt()).strip()
+            except EOFError:
+                print()
+                break
+            except KeyboardInterrupt:
+                print("\nInterrompido.")
+                break
+
+            if not raw:
+                continue
+
+            if raw in {"/exit", "/quit", "sair"}:
+                break
+            if raw == "/help":
+                self._print_help()
+                continue
+            if raw == "/status":
+                self._show_status()
+                continue
+            if raw == "/sync":
+                self._resync_rag()
+                continue
+            if raw in {"/reload-mcps", "/reload"}:
+                self.reload_mcps(sync_rag=True, announce=True)
+                continue
+            if raw == "/auto":
+                self.mode = "AUTO"
+                print("Modo alterado para AUTO")
+                continue
+            if raw == "/pro":
+                self.mode = "PRO"
+                self._switch_model_if_needed(MODEL_PRO)
+                print("Modo alterado para PRO")
+                continue
+            if raw == "/flash":
+                self.mode = "FLASH"
+                self._switch_model_if_needed(MODEL_FLASH)
+                print("Modo alterado para FLASH")
+                continue
+
+            decision = self.route_for_input(raw)
+            self._switch_model_if_needed(decision.model_name)
+
+            self._append_to_history("user", raw)
+
+            full_response = ""
+            try:
+                stream = self.chat.send_message(raw, stream=True)
+                for chunk in stream:
+                    piece = self._extract_text(chunk)
+                    if piece:
+                        full_response += piece
+                        print(piece, end="", flush=True)
+                print()
+                emit_plin()
+            except Exception as exc:
+                print(f"Erro ao gerar resposta: {exc}")
+                self.history.pop()
+                emit_plin()
+                continue
+
+            self._append_to_history("model", full_response)
+            save_history(self.history)
+
+        save_history(self.history)
+        return 0
+
+
+def main() -> int:
+    cli = GeminiToolCLI()
+    return cli.run()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+
+# --- COMANDOS DE INSTALACAO E GIT ---
+# chmod +x gemini_tool.py
+# python3 -m pip install --upgrade google-generativeai
+# git remote add origin https://github.com/JocsaPB/gemini-cli.git
+# git add .
+# git commit -m "Initial release of Gemini-CLI with RAG Sync"
+# git push origin main

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "gemini-cli-pro",
+  "version": "0.0.3-snapshot",
+  "description": "Gemini CLI em Python com sync de RAG local e roteamento Flash/Pro",
+  "license": "MIT",
+  "bin": {
+    "gemini": "bin/gemini"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "gemini_tool.py",
+    "README.md"
+  ],
+  "scripts": {
+    "prepare:publish": "node scripts/prepare-publish.js",
+    "publish:npm": "npm run prepare:publish && npm publish --access public",
+    "install:global": "node scripts/install-global.js",
+    "pack:check": "npm pack --dry-run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "gemini",
+    "cli",
+    "python",
+    "rag",
+    "automation"
+  ]
+}

package/scripts/install-global.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+const { spawnSync } = require("child_process");
+
+function install(pkgName) {
+  const result = spawnSync("npm", ["install", "-g", pkgName], { stdio: "inherit" });
+  return result.status === 0;
+}
+
+const preferred = "gemini-cli-pro";
+const fallback = "gemini-cli";
+
+console.log(`Tentando instalar: ${preferred}`);
+if (install(preferred)) {
+  process.exit(0);
+}
+
+console.log(`Falha ao instalar ${preferred}. Tentando ${fallback}...`);
+if (install(fallback)) {
+  process.exit(0);
+}
+
+console.error("Nao foi possivel instalar nem gemini-cli-pro nem gemini-cli.");
+process.exit(1);

package/scripts/prepare-publish.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+
+const projectDir = path.resolve(__dirname, "..");
+const packageJsonPath = path.join(projectDir, "package.json");
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+const preferred = "gemini-cli-pro";
+packageJson.name = preferred;
+fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+
+console.log(`package.json atualizado para publish com nome: ${packageJson.name}`);