own-rag-cli 0.0.3-snapshot → 0.0.5-snapshot

package/bin/mcp_server.py

@@ -399,7 +399,7 @@ IGNORED_EXTENSIONS = {
     ".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".webp", ".bmp",
     ".mp4", ".mp3", ".wav", ".ogg", ".avi", ".mov",
     ".zip", ".tar", ".gz", ".rar", ".7z", ".jar", ".war",
-    ".pyc", ".pyo", ".so", ".dll", ".exe", ".bin",
+    ".pyc", ".pyo", ".so", ".dll", ".exe", ".bin", ".run",
     ".lock", ".sum", ".sqlite", ".db", ".sqlite3",
     ".ttf", ".woff", ".woff2", ".eot",
     ".pdf", ".docx", ".xlsx", ".pptx",
@@ -804,16 +804,43 @@ def _delete_file_chunks(collection: chromadb.Collection, file_path: str) -> int:
 
 
 def _read_file_safe(filepath: Path) -> str | None:
+    try:
+        raw = filepath.read_bytes()
+    except OSError:
+        return None
+
+    if _looks_binary_content(raw):
+        return None
+
     for encoding in ("utf-8", "latin-1", "cp1252"):
         try:
-            return filepath.read_text(encoding=encoding)
+            return raw.decode(encoding)
         except UnicodeDecodeError:
             continue
-        except OSError:
-            return None
     return None
 
 
+def _looks_binary_content(raw: bytes) -> bool:
+    if not raw:
+        return False
+
+    sample = raw[:4096]
+    if b"\x00" in sample:
+        return True
+
+    non_text_bytes = 0
+    for byte in sample:
+        if byte in (9, 10, 13):  # \t \n \r
+            continue
+        if 32 <= byte <= 126:  # ASCII imprimivel
+            continue
+        if 160 <= byte <= 255:  # Latin-1 estendido
+            continue
+        non_text_bytes += 1
+
+    return (non_text_bytes / len(sample)) > 0.30
+
+
 def _scan_folder(folder_path: Path) -> Iterator[Path]:
     for dirpath, dirnames, filenames in os.walk(folder_path):
         dirnames[:] = [
@@ -871,32 +898,108 @@ def _index_single_file_for_branch(
         _delete_file_chunks(collection, abs_path)
 
     inserted_chunks = 0
+    skipped_chunks = 0
+    stop_iteration_warnings = 0
     batch_ids: list[str] = []
     batch_docs: list[str] = []
     batch_metadatas: list[dict[str, object]] = []
 
+    def _warn_stop_iteration(message: str) -> None:
+        nonlocal stop_iteration_warnings
+        if stop_iteration_warnings < 3:
+            log.warning(message)
+        stop_iteration_warnings += 1
+
+    def _to_embedding_rows(encoded_embeddings: object) -> list[list[float]]:
+        if hasattr(encoded_embeddings, "tolist"):
+            rows = encoded_embeddings.tolist()
+            if isinstance(rows, list):
+                if rows and isinstance(rows[0], (int, float)):
+                    return [list(rows)]
+                return rows
+        return [list(row) for row in encoded_embeddings]  # type: ignore[arg-type]
+
     def _flush_batch() -> None:
-        nonlocal inserted_chunks
+        nonlocal inserted_chunks, skipped_chunks
         if not batch_ids:
             return
-        embeddings = model.encode(
-            batch_docs,
-            show_progress_bar=False,
-            batch_size=EMBEDDING_BATCH_SIZE,
-        ).tolist()
-        collection.upsert(
-            ids=batch_ids,
-            embeddings=embeddings,
-            documents=batch_docs,
-            metadatas=batch_metadatas,
-        )
-        inserted_chunks += len(batch_ids)
-        del embeddings
+
+        pending_ids = list(batch_ids)
+        pending_docs = list(batch_docs)
+        pending_metadatas = list(batch_metadatas)
+
+        try:
+            encoded = model.encode(
+                pending_docs,
+                show_progress_bar=False,
+                batch_size=EMBEDDING_BATCH_SIZE,
+            )
+            embeddings = _to_embedding_rows(encoded)
+            collection.upsert(
+                ids=pending_ids,
+                embeddings=embeddings,
+                documents=pending_docs,
+                metadatas=pending_metadatas,
+            )
+            inserted_chunks += len(pending_ids)
+            del embeddings
+        except StopIteration:
+            _warn_stop_iteration(
+                f"{filepath.name} [{branch.key}] StopIteration no batch; aplicando fallback por chunk."
+            )
+            for chunk_id, chunk_doc, chunk_metadata in zip(pending_ids, pending_docs, pending_metadatas):
+                candidate_doc = chunk_doc.strip()
+                if not candidate_doc:
+                    skipped_chunks += 1
+                    continue
+                try:
+                    encoded_single = model.encode(
+                        [candidate_doc],
+                        show_progress_bar=False,
+                        batch_size=1,
+                    )
+                    single_embeddings = _to_embedding_rows(encoded_single)
+                    collection.upsert(
+                        ids=[chunk_id],
+                        embeddings=single_embeddings,
+                        documents=[candidate_doc],
+                        metadatas=[chunk_metadata],
+                    )
+                    inserted_chunks += 1
+                    del single_embeddings
+                except StopIteration:
+                    compact_doc = " ".join(candidate_doc.split())
+                    if not compact_doc:
+                        skipped_chunks += 1
+                        continue
+                    try:
+                        encoded_single = model.encode(
+                            [compact_doc],
+                            show_progress_bar=False,
+                            batch_size=1,
+                        )
+                        single_embeddings = _to_embedding_rows(encoded_single)
+                        collection.upsert(
+                            ids=[chunk_id],
+                            embeddings=single_embeddings,
+                            documents=[compact_doc],
+                            metadatas=[chunk_metadata],
+                        )
+                        inserted_chunks += 1
+                        del single_embeddings
+                    except StopIteration:
+                        skipped_chunks += 1
+                        _warn_stop_iteration(
+                            f"{filepath.name} [{branch.key}] chunk ignorado após StopIteration repetido."
+                        )
         batch_ids.clear()
         batch_docs.clear()
         batch_metadatas.clear()
 
     for i, chunk in enumerate(chunks):
+        if not chunk or not chunk.strip():
+            skipped_chunks += 1
+            continue
         batch_ids.append(_make_chunk_id(abs_path, i))
         batch_docs.append(chunk)
         batch_metadatas.append(
@@ -914,6 +1017,10 @@ def _index_single_file_for_branch(
             _flush_batch()
 
     _flush_batch()
+    if skipped_chunks:
+        _warn_stop_iteration(
+            f"{filepath.name} [{branch.key}] ignorou {skipped_chunks} chunk(s) vazio(s)/inválido(s)."
+        )
     return inserted_chunks
 
 
@@ -1196,15 +1303,32 @@ def _run_ensemble_mode(query: str, top_k: int) -> tuple[list[FusedHit], list[str
 # Servidor MCP via FastMCP
 # ---------------------------------------------------------------------------
 
-mcp = FastMCP(
-    name="rag-codebase",
-    instructions=(
+FORCE_SEMANTIC_FALLBACK = (
+    os.environ.get("MCP_FORCE_SEMANTIC_FALLBACK", "true").strip().lower()
+    in {"1", "true", "yes", "on"}
+)
+
+
+def _build_server_instructions() -> str:
+    instructions = (
         "Servidor RAG para busca semântica em código-fonte local com suporte a ensemble híbrido. "
         "No modo hybrid, a branch de código usa Jina v2 e a de documentação usa BGE. "
         "Use semantic_search_code(query, top_k, mode='ensemble') para combinar Jina+BGE com RRF e reranking. "
         "Use update_file_index após editar um arquivo para manter as duas coleções sincronizadas. "
         "Use index_specific_folder para indexação recursiva sob demanda."
-    ),
+    )
+    if FORCE_SEMANTIC_FALLBACK:
+        instructions += (
+            " Regra obrigatória: quando a pergunta mencionar função/classe/componente/arquivo "
+            "e isso não estiver no contexto imediato, chame semantic_search_code(mode='ensemble') "
+            "antes de responder que não encontrou. Só conclua ausência após ao menos uma busca semântica."
+        )
+    return instructions
+
+
+mcp = FastMCP(
+    name="rag-codebase",
+    instructions=_build_server_instructions(),
 )
 
 

package/bin/postinstall.sh

@@ -17,6 +17,14 @@ MONITOR_DEST="${LOCAL_BIN_DIR}/chroma_monitor.sh"
 REMOVE_SRC="${PACKAGE_ROOT}/bin/rag-remove.sh"
 REMOVE_DEST="${LOCAL_BIN_DIR}/rag-remove.sh"
 OWN_RAG_CONFIG_FILE="${HOME}/.own-rag-cli.json"
+MCP_SERVER_COMMAND="${HOME}/.local/bin/mcp-rag-server"
+CLAUDE_CONFIG_FILE="${HOME}/.claude.json"
+CURSOR_MCP_CONFIG_1="${HOME}/.cursor/mcp.json"
+CURSOR_MCP_CONFIG_2="${HOME}/.config/Cursor/User/mcp.json"
+CURSOR_RULE_DIR_1="${HOME}/.cursor/rules"
+CURSOR_RULE_DIR_2="${HOME}/.config/Cursor/User/rules"
+CURSOR_RULE_FILE_NAME="own-rag-force-semantic-search.mdc"
+CODEX_CONFIG_FILE="${HOME}/.codex/config.toml"
 
 COMPOSE_SOURCE="${PACKAGE_ROOT}/bin/docker-compose.yml"
 COMPOSE_DIR="${HOME}/docker-chromadb"
@@ -52,10 +60,236 @@ cfg.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encodin
 PYEOF
 }
 
+ensure_mcp_json_config() {
+    local cfg_file="$1"
+    local cfg_label="$2"
+    local update_result
+
+    if ! update_result="$(
+        python3 - "${cfg_file}" "${MCP_SERVER_COMMAND}" "${OWN_RAG_CONFIG_FILE}" <<'PYEOF'
+import json
+import sys
+from pathlib import Path
+
+cfg_path = Path(sys.argv[1]).expanduser()
+mcp_server_command = sys.argv[2]
+own_rag_config = sys.argv[3]
+
+if cfg_path.exists():
+    try:
+        data = json.loads(cfg_path.read_text(encoding="utf-8"))
+    except Exception:
+        data = {}
+else:
+    data = {}
+
+if not isinstance(data, dict):
+    data = {}
+
+mcp_servers = data.get("mcpServers")
+if not isinstance(mcp_servers, dict):
+    mcp_servers = {}
+
+desired = {
+    "command": mcp_server_command,
+    "args": [],
+    "env": {
+        "OWN_RAG_CLI_CONFIG_FILE": own_rag_config,
+        "TOKENIZERS_PARALLELISM": "false",
+        "MCP_FORCE_SEMANTIC_FALLBACK": "true",
+    },
+}
+
+current = mcp_servers.get("rag-codebase")
+if current == desired:
+    print("skip:already_set")
+    raise SystemExit(0)
+
+mcp_servers["rag-codebase"] = desired
+data["mcpServers"] = mcp_servers
+cfg_path.parent.mkdir(parents=True, exist_ok=True)
+cfg_path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+print("updated")
+PYEOF
+    )"; then
+        log_warn "Falha ao atualizar ${cfg_label}: ${cfg_file}"
+        return 1
+    fi
+
+    if [[ "${update_result}" == "updated" ]]; then
+        log_info "${cfg_label} MCP configurado: ${cfg_file}"
+    fi
+    return 0
+}
+
+ensure_codex_mcp_config() {
+    local update_result
+    if ! update_result="$(
+        python3 - "${CODEX_CONFIG_FILE}" "${MCP_SERVER_COMMAND}" "${OWN_RAG_CONFIG_FILE}" <<'PYEOF'
+import re
+import sys
+from pathlib import Path
+
+cfg_path = Path(sys.argv[1]).expanduser()
+mcp_server_command = sys.argv[2]
+own_rag_config = sys.argv[3]
+
+cfg_path.parent.mkdir(parents=True, exist_ok=True)
+if cfg_path.exists():
+    text = cfg_path.read_text(encoding="utf-8")
+else:
+    text = ""
+
+block = (
+    "[mcp_servers.rag-codebase]\n"
+    f'command = "{mcp_server_command}"\n'
+    "args = []\n\n"
+    "[mcp_servers.rag-codebase.env]\n"
+    f'OWN_RAG_CLI_CONFIG_FILE = "{own_rag_config}"\n'
+    'TOKENIZERS_PARALLELISM = "false"\n'
+    'MCP_FORCE_SEMANTIC_FALLBACK = "true"\n'
+)
+
+pattern = re.compile(
+    r"(?ms)^\[mcp_servers\.rag-codebase\]\n.*?(?=^\[mcp_servers\.|^\[[^\]]+\]|$)"
+)
+
+if pattern.search(text):
+    new_text = pattern.sub(block + "\n", text, count=1)
+else:
+    suffix = "" if not text or text.endswith("\n") else "\n"
+    new_text = f"{text}{suffix}\n{block}"
+
+if new_text == text:
+    print("skip:already_set")
+    raise SystemExit(0)
+
+cfg_path.write_text(new_text, encoding="utf-8")
+print("updated")
+PYEOF
+    )"; then
+        log_warn "Falha ao configurar MCP no Codex: ${CODEX_CONFIG_FILE}"
+        return 1
+    fi
+
+    if [[ "${update_result}" == "updated" ]]; then
+        log_info "Codex MCP configurado: ${CODEX_CONFIG_FILE}"
+    fi
+    return 0
+}
+
+ensure_cursor_semantic_rule_files() {
+    local rule_dir
+    local rule_path
+    for rule_dir in "${CURSOR_RULE_DIR_1}" "${CURSOR_RULE_DIR_2}"; do
+        if ! mkdir -p "${rule_dir}" 2>/dev/null; then
+            log_warn "Nao foi possivel criar diretorio de regras do Cursor: ${rule_dir}"
+            continue
+        fi
+
+        rule_path="${rule_dir}/${CURSOR_RULE_FILE_NAME}"
+        if ! cat > "${rule_path}" <<'EOF'
+---
+description: Force semantic_search_code fallback when local context is missing
+alwaysApply: true
+---
+When the prompt asks about a function, class, component, or file that is not present in the current local context,
+call MCP server `rag-codebase` tool `semantic_search_code` with `mode="ensemble"` before saying "not found".
+Only conclude "not found" after at least one semantic_search_code call returns no relevant result.
+If `rag-codebase` appears in available tools, do not claim MCP access is unavailable.
+EOF
+        then
+            log_warn "Nao foi possivel escrever regra do Cursor em: ${rule_path}"
+            continue
+        fi
+
+        log_info "Regra do Cursor instalada: ${rule_path}"
+    done
+}
+
+ensure_cursor_force_fallback_env() {
+    local cfg_file
+    local update_result
+
+    for cfg_file in "${CURSOR_MCP_CONFIG_1}" "${CURSOR_MCP_CONFIG_2}"; do
+        if [[ ! -f "${cfg_file}" ]]; then
+            continue
+        fi
+
+        if ! update_result="$(
+            python3 - "${cfg_file}" <<'PYEOF'
+import json
+import sys
+from pathlib import Path
+
+cfg_path = Path(sys.argv[1]).expanduser()
+
+try:
+    data = json.loads(cfg_path.read_text(encoding="utf-8"))
+except Exception:
+    print("skip:invalid_json")
+    raise SystemExit(0)
+
+if not isinstance(data, dict):
+    print("skip:invalid_root")
+    raise SystemExit(0)
+
+mcp_servers = data.get("mcpServers")
+if not isinstance(mcp_servers, dict):
+    print("skip:no_mcp_servers")
+    raise SystemExit(0)
+
+rag_cfg = mcp_servers.get("rag-codebase")
+if not isinstance(rag_cfg, dict):
+    print("skip:no_rag_codebase")
+    raise SystemExit(0)
+
+env = rag_cfg.get("env")
+if not isinstance(env, dict):
+    env = {}
+
+if str(env.get("MCP_FORCE_SEMANTIC_FALLBACK", "")).strip().lower() in {"1", "true", "yes", "on"}:
+    print("skip:already_set")
+    raise SystemExit(0)
+
+env["MCP_FORCE_SEMANTIC_FALLBACK"] = "true"
+rag_cfg["env"] = env
+mcp_servers["rag-codebase"] = rag_cfg
+data["mcpServers"] = mcp_servers
+
+cfg_path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+print("updated")
+PYEOF
+        )"; then
+            log_warn "Falha ao ajustar fallback MCP no Cursor: ${cfg_file}"
+            continue
+        fi
+
+        if [[ "${update_result}" == "updated" ]]; then
+            log_info "Cursor MCP atualizado com MCP_FORCE_SEMANTIC_FALLBACK=true: ${cfg_file}"
+        fi
+    done
+}
+
 mkdir -p "${LOCAL_BIN_DIR}"
 ensure_own_rag_cli_config
 log_info "Config criada/ok: ${OWN_RAG_CONFIG_FILE}"
 
+if command -v cursor >/dev/null 2>&1 || [[ -d "${HOME}/.cursor" ]] || [[ -d "${HOME}/.config/Cursor" ]]; then
+    ensure_mcp_json_config "${CURSOR_MCP_CONFIG_1}" "Cursor"
+    ensure_mcp_json_config "${CURSOR_MCP_CONFIG_2}" "Cursor"
+    ensure_cursor_semantic_rule_files
+    ensure_cursor_force_fallback_env
+fi
+
+if command -v claude >/dev/null 2>&1 || [[ -d "${HOME}/.claude" ]] || [[ -f "${CLAUDE_CONFIG_FILE}" ]]; then
+    ensure_mcp_json_config "${CLAUDE_CONFIG_FILE}" "Claude"
+fi
+
+if command -v codex >/dev/null 2>&1 || [[ -d "${HOME}/.codex" ]] || [[ -f "${CODEX_CONFIG_FILE}" ]]; then
+    ensure_codex_mcp_config
+fi
+
 if [[ -f "${WRAPPER_SRC}" ]]; then
     cp "${WRAPPER_SRC}" "${WRAPPER_DEST}"
     chmod +x "${WRAPPER_DEST}"

package/bin/rag-wrapper.sh

@@ -12,6 +12,8 @@ PACKAGE_MONITOR_SCRIPT="${SCRIPT_DIR}/../chroma_monitor.sh"
 LOCAL_REMOVE_SCRIPT="${LOCAL_BIN_DIR}/rag-remove.sh"
 PACKAGE_REMOVE_SCRIPT="${SCRIPT_DIR}/../bin/rag-remove.sh"
 
+URL_TEMP_DIR=""
+
 detect_os() {
     case "$(uname -s)" in
         Darwin) echo "macos" ;;
@@ -99,16 +101,140 @@ find_remove_runner() {
     return 1
 }
 
+cleanup_url_temp_dir() {
+    if [[ -n "${URL_TEMP_DIR}" && -d "${URL_TEMP_DIR}" ]]; then
+        rm -rf "${URL_TEMP_DIR}" || true
+    fi
+}
+
+run_with_privilege() {
+    if [[ "$(id -u)" -eq 0 ]]; then
+        "$@"
+        return
+    fi
+    if command -v sudo >/dev/null 2>&1; then
+        sudo "$@"
+        return
+    fi
+    "$@"
+}
+
+install_package_if_missing() {
+    local package_name="$1"
+    local os_name="$2"
+
+    if command -v "${package_name}" >/dev/null 2>&1; then
+        return 0
+    fi
+
+    echo "Aviso: '${package_name}' não encontrado. Tentando instalar..." >&2
+
+    case "${os_name}" in
+        linux)
+            if command -v apt-get >/dev/null 2>&1; then
+                run_with_privilege apt-get update -y
+                run_with_privilege apt-get install -y "${package_name}"
+            elif command -v dnf >/dev/null 2>&1; then
+                run_with_privilege dnf install -y "${package_name}"
+            elif command -v yum >/dev/null 2>&1; then
+                run_with_privilege yum install -y "${package_name}"
+            elif command -v pacman >/dev/null 2>&1; then
+                run_with_privilege pacman -Sy --noconfirm "${package_name}"
+            elif command -v zypper >/dev/null 2>&1; then
+                run_with_privilege zypper --non-interactive install "${package_name}"
+            elif command -v apk >/dev/null 2>&1; then
+                run_with_privilege apk add --no-cache "${package_name}"
+            else
+                echo "Erro: não foi possível instalar '${package_name}' automaticamente nesta distro Linux." >&2
+                return 1
+            fi
+            ;;
+        macos)
+            if command -v brew >/dev/null 2>&1; then
+                brew install "${package_name}"
+            else
+                echo "Erro: '${package_name}' ausente e Homebrew não encontrado no macOS." >&2
+                echo "Instale manualmente e tente novamente." >&2
+                return 1
+            fi
+            ;;
+        *)
+            echo "Erro: sistema operacional não suportado para instalação automática de '${package_name}'." >&2
+            return 1
+            ;;
+    esac
+
+    if ! command -v "${package_name}" >/dev/null 2>&1; then
+        echo "Erro: instalação de '${package_name}' falhou." >&2
+        return 1
+    fi
+    return 0
+}
+
+is_url_input() {
+    local value="$1"
+    [[ "${value}" =~ ^https?:// ]]
+}
+
+looks_like_zip_file() {
+    local file_path="$1"
+    local signature
+    signature="$(LC_ALL=C head -c 4 "${file_path}" | od -An -tx1 | tr -d ' \n' || true)"
+    case "${signature}" in
+        504b0304|504b0506|504b0708) return 0 ;;
+    esac
+    return 1
+}
+
+prepare_url_source() {
+    local remote_url="$1"
+    local os_name="$2"
+    local file_hint
+    local download_name
+    local download_path
+    local extract_dir
+
+    install_package_if_missing "curl" "${os_name}" >/dev/null
+
+    URL_TEMP_DIR="$(mktemp -d "${TMPDIR:-/tmp}/own-rag-url.XXXXXX")"
+    trap cleanup_url_temp_dir EXIT
+
+    file_hint="${remote_url%%\?*}"
+    download_name="$(basename "${file_hint}")"
+    if [[ -z "${download_name}" || "${download_name}" == "/" || "${download_name}" == "." ]]; then
+        download_name="downloaded-content"
+    fi
+    download_path="${URL_TEMP_DIR}/${download_name}"
+
+    echo "Baixando conteúdo remoto: ${remote_url}" >&2
+    curl -fL --retry 2 --connect-timeout 20 --max-time 600 \
+        -o "${download_path}" "${remote_url}"
+
+    if looks_like_zip_file "${download_path}"; then
+        install_package_if_missing "unzip" "${os_name}" >/dev/null
+        extract_dir="${URL_TEMP_DIR}/extracted"
+        mkdir -p "${extract_dir}"
+        unzip -q "${download_path}" -d "${extract_dir}"
+        echo "Conteúdo ZIP extraído para indexação temporária." >&2
+        echo "${extract_dir}"
+        return 0
+    fi
+
+    echo "${URL_TEMP_DIR}"
+}
+
 usage() {
     cat <<'EOF'
 Uso:
-  rag run [path]
+  rag run [path|url]
   rag monitor [command]
   rag remove
 
 Exemplos:
   rag run .
   rag run /caminho/do/projeto
+  rag run https://exemplo.com/documentacao.md
+  rag run https://exemplo.com/pacote.zip
   rag monitor
   rag monitor full
   rag remove
@@ -132,24 +258,21 @@ fi
 
 case "${command_name}" in
     run)
-        target_path="${1:-}"
-        if [[ -z "${target_path}" ]]; then
+        target_input="${1:-}"
+        shift || true
+
+        if [[ -z "${target_input}" ]]; then
             printf "⚠️ Pasta não informada. Deseja usar a pasta atual: %s? (s/n)\n" "${PWD}"
             read -r answer
             answer="$(echo "${answer}" | tr '[:upper:]' '[:lower:]')"
             if [[ "${answer}" == "s" || "${answer}" == "sim" || "${answer}" == "y" || "${answer}" == "yes" ]]; then
-                target_path="${PWD}"
+                target_input="${PWD}"
             else
                 echo "Dica: use 'rag run /caminho/do/projeto'."
                 exit 1
             fi
         fi
 
-        if [[ ! -d "${target_path}" ]]; then
-            echo "Erro: caminho não encontrado ou não é diretório: ${target_path}" >&2
-            exit 1
-        fi
-
         if ! setup_runner="$(find_setup_runner "${os_name}")"; then
             if [[ "${os_name}" == "macos" ]]; then
                 echo "Erro: rag-setup-macos.run não encontrado." >&2
@@ -161,7 +284,25 @@ case "${command_name}" in
             exit 1
         fi
 
-        exec "${setup_runner}" "${target_path}"
+        if is_url_input "${target_input}"; then
+            if ! target_path="$(prepare_url_source "${target_input}" "${os_name}")"; then
+                echo "Erro: falha ao preparar conteúdo remoto para indexação: ${target_input}" >&2
+                exit 1
+            fi
+            echo "Indexando conteúdo baixado temporariamente em: ${target_path}" >&2
+            "${setup_runner}" "${target_path}" "$@"
+            cleanup_url_temp_dir
+            trap - EXIT
+            exit 0
+        fi
+
+        target_path="${target_input}"
+        if [[ ! -d "${target_path}" ]]; then
+            echo "Erro: caminho não encontrado ou não é diretório: ${target_path}" >&2
+            exit 1
+        fi
+
+        exec "${setup_runner}" "${target_path}" "$@"
         ;;
     monitor)
         if ! monitor_runner="$(find_monitor_runner "${os_name}")"; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "own-rag-cli",
-  "version": "0.0.3-snapshot",
+  "version": "0.0.5-snapshot",
   "description": "Local RAG setup with ChromaDB + MCP server (Jina/BGE hybrid support).",
   "license": "MIT",
   "private": false,