ravmem-cli 0.1.0__py3-none-any.whl

ravmem/cli/search.py

@@ -0,0 +1,91 @@
+"""ravmem search — hybrid symbol search via the remote server."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+
+def _detect_branch(repo_path: Path, explicit: str | None) -> str:
+    if explicit:
+        return explicit
+    try:
+        out = subprocess.run(
+            ["git", "-C", str(repo_path), "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip()
+        return out if out and out != "HEAD" else "main"
+    except Exception:
+        return "main"
+
+
+def _get_client(remote: str | None):
+    from ravmem.client.api import RavMemClient
+    from ravmem.client.config import load_config
+
+    url = remote
+    api_key = None
+    if not url:
+        cfg = load_config()
+        url = cfg.get("server_url")
+        api_key = cfg.get("api_key")
+    if not url:
+        typer.echo(
+            "Error: No server configured. "
+            "Run `ravmem remote config --url <URL>` or pass --remote <URL>.",
+            err=True,
+        )
+        raise typer.Exit(1)
+    return RavMemClient(base_url=url, api_key=api_key or None)
+
+
+def search_cmd(
+    query: str = typer.Argument(..., help="Search query"),
+    repo: Path = typer.Option(Path("."), "--repo", "-r", help="Path to the repository (used for branch auto-detection)"),
+    limit: int = typer.Option(10, "--limit", "-n", help="Number of results"),
+    remote: Optional[str] = typer.Option(None, "--remote", help="Server URL (overrides config)"),
+    project: Optional[str] = typer.Option(None, "--project", help="Project ID on the server"),
+    branch: Optional[str] = typer.Option(None, "--branch", help="Branch name (auto-detected from git if omitted)"),
+    output_json: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    """Search symbols using hybrid BM25 + semantic search."""
+    import json
+
+    repo_path = repo.resolve()
+    branch_name = _detect_branch(repo_path, branch)
+
+    if not project:
+        typer.echo("--project is required. Use `ravmem remote add` to register the repo first.", err=True)
+        raise typer.Exit(1)
+
+    client = _get_client(remote)
+    try:
+        results = client.search(project, branch_name, query, limit=limit)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(results, default=str))
+        return
+
+    if not results:
+        typer.echo("No results found.")
+        return
+
+    typer.echo(f"\nResults for '{query}' on branch '{branch_name}':\n")
+    for i, r in enumerate(results, 1):
+        sym = r.get("symbol", {})
+        name = sym.get("name", "")
+        kind = sym.get("kind", "")
+        file = sym.get("file", "")
+        line = sym.get("line_start", "")
+        score = r.get("score", 0.0)
+        location = f"{Path(file).name}:{line}" if file else ""
+        match_type = r.get("match_type", "hybrid")
+        typer.echo(
+            f"  {i:2}. [{match_type:8}] {typer.style(name, bold=True)} "
+            f"({kind})  {location}  score={score:.4f}"
+        )

ravmem/cli/serve.py

@@ -0,0 +1,41 @@
+"""ravmem serve — start the FastAPI server."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ravmem.config import DEFAULT_HOST, DEFAULT_PORT, SERVER_DATA_DIR
+
+
+def serve_cmd(
+    repos_dir: Path = typer.Option(
+        SERVER_DATA_DIR / "repos",
+        "--repos-dir",
+        help="Directory containing indexed repositories",
+    ),
+    host: str = typer.Option(DEFAULT_HOST, "--host", help="Bind host"),
+    port: int = typer.Option(DEFAULT_PORT, "--port", "-p", help="Bind port"),
+    reload: bool = typer.Option(False, "--reload", help="Auto-reload on code changes (dev)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable debug logging"),
+    config: Optional[str] = typer.Option(None, "--config", help="Path to ravmem.yaml config file"),
+) -> None:
+    """Start the RavMem API server (REST + MCP + WebSocket)."""
+    from ravmem.cli.main import setup_logging
+    import uvicorn
+    from ravmem.config_loader import reload_config
+    from ravmem.server.app import create_app
+
+    # Load config before anything else so all components see it
+    reload_config(config)
+
+    setup_logging(verbose)
+    repos_path = repos_dir.resolve()
+    typer.echo(f"Starting RavMem server on http://{host}:{port}")
+    typer.echo(f"Repos directory: {repos_path}")
+    typer.echo(f"MCP endpoint:    http://{host}:{port}/mcp")
+
+    app = create_app(repos_dir=repos_path)
+    uvicorn.run(app, host=host, port=port, reload=reload)

ravmem/client/__init__.py

@@ -0,0 +1,3 @@
+from ravmem.client.api import RavMemClient
+
+__all__ = ["RavMemClient"]

ravmem/client/api.py

@@ -0,0 +1,279 @@
+"""Synchronous HTTP client for a remote RavMem server."""
+
+from __future__ import annotations
+
+import time
+
+import httpx
+
+
+class RavMemClient:
+    """Thin wrapper around the RavMem REST API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        headers: dict[str, str] = {}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        self._client = httpx.Client(
+            base_url=base_url, headers=headers, timeout=timeout
+        )
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Internal helper
+    # ------------------------------------------------------------------
+
+    def _request(self, method: str, path: str, **kwargs) -> dict | list:
+        resp = self._client.request(method, path, **kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    # ------------------------------------------------------------------
+    # Projects
+    # ------------------------------------------------------------------
+
+    def create_project(
+        self,
+        git_url: str | None = None,
+        git_username: str | None = None,
+        git_token: str | None = None,
+        repo_path: str | None = None,
+        mount: bool = False,
+        name: str | None = None,
+        default_branch: str = "main",
+        langs: list[str] | None = None,
+    ) -> dict:
+        body: dict = {"default_branch": default_branch, "mount": mount}
+        if git_url is not None:
+            body["git_url"] = git_url
+        if git_username is not None:
+            body["git_username"] = git_username
+        if git_token is not None:
+            body["git_token"] = git_token
+        if repo_path is not None:
+            body["repo_path"] = repo_path
+        if name is not None:
+            body["name"] = name
+        if langs is not None:
+            body["langs"] = langs
+        return self._request("POST", "/api/projects", json=body)
+
+    def list_projects(self) -> list[dict]:
+        return self._request("GET", "/api/projects")
+
+    def get_project(self, project_id: str) -> dict:
+        return self._request("GET", f"/api/projects/{project_id}")
+
+    def delete_project(self, project_id: str) -> dict:
+        return self._request("DELETE", f"/api/projects/{project_id}")
+
+    # ------------------------------------------------------------------
+    # Branches
+    # ------------------------------------------------------------------
+
+    def sync_workspace(self, project_id: str) -> dict:
+        """Fetch the latest remote commits into the server-side workspace.
+
+        Returns ``{synced, fetched_branches, fetched_commits, workspace_head, duration_ms}``.
+        """
+        return self._request("POST", f"/api/projects/{project_id}/workspace/sync")
+
+    def reset_workspace(self, project_id: str) -> dict:
+        """Delete the server-side workspace and clear all branch index records.
+
+        Returns ``{reset: True, removed_workspace: bool, branches_cleared: int}``.
+        """
+        return self._request("POST", f"/api/projects/{project_id}/workspace/reset")
+
+    def set_credentials(self, project_id: str, git_username: str, git_token: str) -> dict:
+        """Store or replace git credentials for a clone-mode project.
+
+        Returns ``{stored: True}``.
+        """
+        return self._request(
+            "POST",
+            f"/api/projects/{project_id}/credentials",
+            json={"git_username": git_username, "git_token": git_token},
+        )
+
+    def delete_credentials(self, project_id: str) -> dict:
+        """Remove stored git credentials for a clone-mode project.
+
+        Returns ``{deleted: bool}``.
+        """
+        return self._request("DELETE", f"/api/projects/{project_id}/credentials")
+
+    def clone_project(self, project_id: str, branch: str | None = None) -> dict:
+        """Trigger initial clone + index for a clone-mode project.
+
+        Returns ``{"job_id": N}``.
+        """
+        params: dict = {}
+        if branch is not None:
+            params["branch"] = branch
+        return self._request(
+            "POST", f"/api/projects/{project_id}/index/clone", params=params
+        )
+
+    def upload_batch(
+        self,
+        project_id: str,
+        branch: str,
+        batch_index: int,
+        batch_total: int,
+        files: list[dict],
+        parent_branch: str | None = None,
+        to_commit: str = "",
+        from_commit: str = "",
+        mode: str = "full",
+        deleted_paths: list[str] | None = None,
+        langs: list[str] | None = None,
+    ) -> dict:
+        """POST one file batch to POST /api/projects/{id}/index.
+
+        Returns ``{"pending": True, "batch_index": N}`` for intermediate batches
+        and ``{"job_id": N}`` for the final batch.
+        """
+        body: dict = {
+            "branch": branch,
+            "to_commit": to_commit,
+            "from_commit": from_commit,
+            "mode": mode,
+            "batch_index": batch_index,
+            "batch_total": batch_total,
+            "files": files,
+            "deleted_paths": deleted_paths or [],
+        }
+        if parent_branch is not None:
+            body["parent_branch"] = parent_branch
+        if langs is not None:
+            body["langs"] = langs
+        return self._request("POST", f"/api/projects/{project_id}/index", json=body)
+
+    def index_branch(
+        self, project_id: str, branch: str, mode: str = "auto",
+        langs: list[str] | None = None,
+        no_auto_sync: bool = False,
+    ) -> dict:
+        body: dict = {"mode": mode}
+        if langs is not None:
+            body["langs"] = langs
+        if no_auto_sync:
+            body["no_auto_sync"] = True
+        return self._request(
+            "POST",
+            f"/api/projects/{project_id}/branches/{branch}/index",
+            json=body,
+        )
+
+    def list_branches(self, project_id: str) -> list[dict]:
+        return self._request("GET", f"/api/projects/{project_id}/branches")
+
+    def get_branch_status(self, project_id: str, branch: str) -> dict:
+        return self._request(
+            "GET", f"/api/projects/{project_id}/branches/{branch}/status"
+        )
+
+    def delete_branch_index(self, project_id: str, branch: str) -> dict:
+        return self._request(
+            "DELETE", f"/api/projects/{project_id}/branches/{branch}/index"
+        )
+
+    def get_divergence(self, project_id: str, branch: str) -> dict:
+        """Pre-flight check: returns changed_files, total_files, ratio, recommend, force_push."""
+        return self._request(
+            "GET", f"/api/projects/{project_id}/branches/{branch}/divergence"
+        )
+
+    def update_project(self, project_id: str, default_branch: str) -> dict:
+        """Update project metadata (e.g. change the default/parent branch)."""
+        return self._request(
+            "PATCH", f"/api/projects/{project_id}", json={"default_branch": default_branch}
+        )
+
+    # ------------------------------------------------------------------
+    # Queries
+    # ------------------------------------------------------------------
+
+    def search(
+        self,
+        project_id: str,
+        branch: str,
+        query: str,
+        limit: int = 20,
+    ) -> list[dict]:
+        return self._request(
+            "GET",
+            f"/api/projects/{project_id}/branches/{branch}/search",
+            params={"q": query, "limit": limit},
+        )
+
+    def impact(
+        self,
+        project_id: str,
+        branch: str,
+        symbol_id: str,
+        depth: int = 3,
+    ) -> dict:
+        return self._request(
+            "GET",
+            f"/api/projects/{project_id}/branches/{branch}/impact/{symbol_id}",
+            params={"depth": depth},
+        )
+
+    def get_symbol(
+        self, project_id: str, branch: str, symbol_id: str
+    ) -> dict:
+        return self._request(
+            "GET",
+            f"/api/projects/{project_id}/branches/{branch}/symbols/{symbol_id}",
+        )
+
+    def get_clusters(self, project_id: str, branch: str) -> list[dict]:
+        return self._request(
+            "GET",
+            f"/api/projects/{project_id}/branches/{branch}/clusters",
+        )
+
+    # ------------------------------------------------------------------
+    # Jobs
+    # ------------------------------------------------------------------
+
+    def get_job(self, job_id: int) -> dict:
+        return self._request("GET", f"/api/jobs/{job_id}")
+
+    def poll_job(
+        self,
+        job_id: int,
+        interval: float = 2.0,
+        timeout: float = 600.0,
+    ) -> dict:
+        """Block until the job reaches a terminal state or *timeout* elapses."""
+        deadline = time.monotonic() + timeout
+        while True:
+            job = self.get_job(job_id)
+            status = job.get("status", "")
+            if status in ("done", "failed", "cancelled"):
+                return job
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"Job {job_id} did not complete within {timeout}s"
+                )
+            time.sleep(interval)

ravmem/client/config.py

@@ -0,0 +1,52 @@
+"""Client configuration — manages ~/.ravmem/client.json."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from ravmem.config import GLOBAL_DIR
+
+CONFIG_PATH = GLOBAL_DIR / "client.json"
+
+_DEFAULTS = {
+    "server_url": "",
+    "api_key": "",
+    "default_project": "",
+    "default_branch": "",
+}
+
+
+def load_config() -> dict:
+    """Read client config from disk; returns defaults if file is missing."""
+    if not CONFIG_PATH.exists():
+        return dict(_DEFAULTS)
+    try:
+        data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+        # Merge with defaults so new keys are always present
+        merged = dict(_DEFAULTS)
+        merged.update(data)
+        return merged
+    except (json.JSONDecodeError, OSError):
+        return dict(_DEFAULTS)
+
+
+def save_config(config: dict) -> None:
+    """Write client config to disk, creating parent dirs if needed."""
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(
+        json.dumps(config, indent=2) + "\n", encoding="utf-8"
+    )
+
+
+def get_client_from_config():
+    """Return a RavMemClient from saved config, or None if not configured."""
+    from ravmem.client.api import RavMemClient
+
+    cfg = load_config()
+    if not cfg.get("server_url"):
+        return None
+    return RavMemClient(
+        base_url=cfg["server_url"],
+        api_key=cfg.get("api_key") or None,
+    )

ravmem/config.py

@@ -0,0 +1,103 @@
+"""Global constants and configuration defaults for RavMem."""
+
+import os
+from pathlib import Path
+
+# Storage directory inside each indexed repo
+INDEX_DIR = ".ravmem"
+
+# Sub-paths within INDEX_DIR
+GRAPH_SUBDIR = "graph"
+VECTORS_SUBDIR = "vectors"
+META_DB_NAME = "meta.db"
+BM25_INDEX_NAME = "bm25.json"
+CONFIG_SNAPSHOT_NAME = "config.json"
+
+# Global user-level directory
+GLOBAL_DIR = Path.home() / ".ravmem"
+MODELS_DIR = GLOBAL_DIR / "models"
+REGISTRY_DB = GLOBAL_DIR / "registry.db"
+
+# Server data directory (centralised index storage for server mode)
+SERVER_DATA_DIR = Path(os.environ.get("RAVMEM_DATA_DIR", str(GLOBAL_DIR / "server")))
+
+# API key for server authentication (empty = auth disabled)
+RAVMEM_API_KEY = os.environ.get("RAVMEM_API_KEY", "")
+
+# Auth system config
+RAVMEM_ADMIN_TOKEN = os.environ.get("RAVMEM_ADMIN_TOKEN", "")
+RAVMEM_SYSTEM_DB = os.environ.get("RAVMEM_SYSTEM_DB", "ravmem_system")
+RAVMEM_AUDIT_LOG_RETENTION_DAYS = int(os.environ.get("RAVMEM_AUDIT_LOG_RETENTION_DAYS", "90"))
+
+# ArcadeDB connection config
+ARCADEDB_HOST = os.environ.get("ARCADEDB_HOST", "localhost")
+ARCADEDB_PORT = int(os.environ.get("ARCADEDB_PORT", "2480"))
+ARCADEDB_PASSWORD = os.environ.get("ARCADEDB_PASSWORD", "arcadedb")
+
+# Shared ArcadeDB database name (single DB for all branches; isolation via branch property)
+ARCADE_DB_NAME = "codegraph"
+
+# Embedding model
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+EMBEDDING_DIM = 384
+
+# Server defaults
+DEFAULT_HOST = "0.0.0.0"
+DEFAULT_PORT = 7432
+
+# Indexing defaults
+DEFAULT_LANGS = ["python", "typescript", "javascript", "go"]
+MAX_FILE_SIZE_KB = 500  # skip files larger than this
+
+# Clustering
+CLUSTER_SEED = int(os.environ.get("RAVMEM_CLUSTER_SEED", "42"))
+CLUSTER_RESOLUTION = float(os.environ.get("RAVMEM_CLUSTER_RESOLUTION", "1.0"))
+CLUSTER_MAX_SIZE = int(os.environ.get("RAVMEM_CLUSTER_MAX_SIZE", "500"))
+CLUSTER_SUBCLUSTER_THRESHOLD = int(os.environ.get("RAVMEM_CLUSTER_SUBCLUSTER_THRESHOLD", "200"))
+
+# OIDC / SSO config (all optional; OIDC is disabled when OIDC_ISSUER_URL is not set)
+OIDC_ENABLED = os.environ.get("RAVMEM_OIDC_ENABLED", "").lower() in ("1", "true", "yes")
+OIDC_ISSUER_URL = os.environ.get("RAVMEM_OIDC_ISSUER_URL", "").rstrip("/")
+OIDC_CLIENT_ID = os.environ.get("RAVMEM_OIDC_CLIENT_ID", "")
+OIDC_CLIENT_SECRET = os.environ.get("RAVMEM_OIDC_CLIENT_SECRET", "")
+OIDC_SCOPES = os.environ.get("RAVMEM_OIDC_SCOPES", "openid email profile")
+
+# Language → file extension mapping
+LANG_EXTENSIONS: dict[str, list[str]] = {
+    "python": [".py"],
+    "typescript": [".ts", ".tsx"],
+    "javascript": [".js", ".jsx"],
+    "go": [".go"],
+    "rust": [".rs"],
+    "java": [".java"],
+    "csharp": [".cs"],
+    "php": [".php"],
+    "ruby": [".rb"],
+    "kotlin": [".kt", ".kts"],
+    "c": [".c", ".h"],
+    "cpp": [".cpp", ".cc", ".cxx", ".hpp"],
+    "shell": [".sh", ".bash"],
+}
+
+EXT_TO_LANG: dict[str, str] = {
+    ext: lang for lang, exts in LANG_EXTENSIONS.items() for ext in exts
+}
+
+# Default ignore patterns (similar to .gitignore)
+DEFAULT_IGNORE_PATTERNS = [
+    ".git",
+    ".ravmem",
+    "__pycache__",
+    "node_modules",
+    ".venv",
+    "venv",
+    "env",
+    "dist",
+    "build",
+    "*.egg-info",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    "*.min.js",
+    "*.bundle.js",
+]