ravmem-cli 0.1.0__py3-none-any.whl

ravmem/cli/browse.py

@@ -0,0 +1,144 @@
+"""ravmem clusters / symbols — browse indexed code graph data."""
+
+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("No server configured. Run: ravmem remote config --url <URL>", err=True)
+        raise typer.Exit(1)
+    return RavMemClient(base_url=url, api_key=api_key or None)
+
+
+def clusters_cmd(
+    repo: Path = typer.Option(Path("."), "--repo", "-r", help="Repo path for branch auto-detection"),
+    remote: Optional[str] = typer.Option(None, "--remote", help="Server URL override"),
+    project: Optional[str] = typer.Option(None, "--project", help="Project ID"),
+    branch: Optional[str] = typer.Option(None, "--branch", help="Branch name"),
+    output_json: bool = typer.Option(False, "--json", help="Raw JSON output"),
+) -> None:
+    """List all clusters for a branch."""
+    import json
+    from rich.console import Console
+    from rich.table import Table
+    from rich import box
+
+    if not project:
+        typer.echo("--project is required.", err=True)
+        raise typer.Exit(1)
+
+    branch_name = _detect_branch(repo.resolve(), branch)
+    client = _get_client(remote)
+    try:
+        clusters = client.get_clusters(project, branch_name)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(clusters, indent=2, default=str))
+        return
+
+    if not clusters:
+        typer.echo("No clusters found.")
+        return
+
+    console = Console()
+    t = Table(box=box.SIMPLE, show_header=True, header_style="bold")
+    t.add_column("Cluster ID", width=18)
+    t.add_column("Label", width=40)
+    t.add_column("Symbols", justify="right", width=8)
+    for c in clusters:
+        t.add_row(
+            str(c.get("id", ""))[:18],
+            str(c.get("label", c.get("id", "")))[:40],
+            str(c.get("symbol_count", c.get("size", "?"))),
+        )
+    console.print(t)
+    console.print(f"[dim]{len(clusters)} cluster(s) on branch '{branch_name}'[/dim]")
+
+
+def symbols_cmd(
+    path: str = typer.Argument(..., help="File path (exact) or directory prefix"),
+    repo: Path = typer.Option(Path("."), "--repo", "-r", help="Repo path for branch auto-detection"),
+    remote: Optional[str] = typer.Option(None, "--remote", help="Server URL override"),
+    project: Optional[str] = typer.Option(None, "--project", help="Project ID"),
+    branch: Optional[str] = typer.Option(None, "--branch", help="Branch name"),
+    prefix: bool = typer.Option(False, "--prefix", "-p",
+        help="Treat path as a directory prefix (list all files under it)"),
+    output_json: bool = typer.Option(False, "--json", help="Raw JSON output"),
+) -> None:
+    """List symbols in a file or directory."""
+    import json
+    from rich.console import Console
+    from rich.table import Table
+    from rich import box
+
+    if not project:
+        typer.echo("--project is required.", err=True)
+        raise typer.Exit(1)
+
+    branch_name = _detect_branch(repo.resolve(), branch)
+    client = _get_client(remote)
+    try:
+        result = client._request(
+            "GET",
+            f"/api/projects/{project}/branches/{branch_name}/files/symbols",
+            params={"path": path, "prefix": str(prefix).lower()},
+        )
+    finally:
+        client.close()
+
+    symbols = result if isinstance(result, list) else result.get("symbols", [])
+
+    if output_json:
+        typer.echo(json.dumps(symbols, indent=2, default=str))
+        return
+
+    if not symbols:
+        typer.echo(f"No symbols found for path: {path}")
+        return
+
+    console = Console()
+    t = Table(box=box.SIMPLE, show_header=True, header_style="bold")
+    t.add_column("Name", width=30)
+    t.add_column("Kind", width=12)
+    t.add_column("File", width=35)
+    t.add_column("Line", justify="right", width=6)
+    for s in symbols:
+        file_short = Path(str(s.get("file", ""))).name
+        t.add_row(
+            str(s.get("name", ""))[:30],
+            str(s.get("kind", "")),
+            file_short[:35],
+            str(s.get("line_start", "")),
+        )
+    console.print(t)
+    console.print(f"[dim]{len(symbols)} symbol(s)[/dim]")

ravmem/cli/config_cmd.py

@@ -0,0 +1,69 @@
+"""ravmem config — inspect and validate the resolved configuration."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+import yaml
+
+app = typer.Typer(help="Inspect or validate the ravmem configuration.", no_args_is_help=True)
+
+_SENSITIVE = {"password", "admin_token"}
+
+
+def _redact(data: object, path: tuple[str, ...] = ()) -> object:
+    """Recursively redact sensitive keys for display."""
+    if isinstance(data, dict):
+        return {
+            k: ("***REDACTED***" if k in _SENSITIVE else _redact(v, path + (k,)))
+            for k, v in data.items()
+        }
+    return data
+
+
+@app.command("show")
+def show_cmd(
+    section: Optional[str] = typer.Option(None, "--section", "-s", help="Show only this top-level section"),
+    config: Optional[str] = typer.Option(None, "--config", "-c", help="Path to ravmem.yaml"),
+) -> None:
+    """Print the resolved configuration as YAML (sensitive values redacted)."""
+    from ravmem.config_loader import load_config
+
+    try:
+        cfg = load_config(config)
+    except ValueError as exc:
+        typer.echo(f"[error] {exc}", err=True)
+        raise typer.Exit(1)
+
+    data = cfg.model_dump()
+    data = _redact(data)
+
+    if section:
+        if section not in data:
+            typer.echo(f"[error] Unknown section '{section}'. Available: {', '.join(data)}", err=True)
+            raise typer.Exit(1)
+        data = {section: data[section]}
+
+    typer.echo(yaml.dump(data, default_flow_style=False, sort_keys=False).rstrip())
+
+
+@app.command("validate")
+def validate_cmd(
+    config: Optional[str] = typer.Option(None, "--config", "-c", help="Path to ravmem.yaml"),
+) -> None:
+    """Validate the config file, print any errors, and exit non-zero on failure."""
+    from ravmem.config_loader import _find_config_file, load_config
+
+    found = _find_config_file(config)
+    if not found:
+        typer.echo("No config file found — using built-in defaults (all valid).")
+        raise typer.Exit(0)
+
+    typer.echo(f"Validating {found} …")
+    try:
+        load_config(config)
+        typer.echo("[ok] Config is valid.")
+    except ValueError as exc:
+        typer.echo(f"[error] {exc}", err=True)
+        raise typer.Exit(1)

ravmem/cli/diff.py

@@ -0,0 +1,122 @@
+"""ravmem diff-impact — blast radius from a git diff."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+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("No server configured. Run: ravmem remote config --url <URL>", err=True)
+        raise typer.Exit(1)
+    return RavMemClient(base_url=url, api_key=api_key or None)
+
+
+def diff_impact_cmd(
+    diff_path: Optional[Path] = typer.Argument(None,
+        help="Path to unified diff file. Reads stdin if omitted."),
+    repo: Path = typer.Option(Path("."), "--repo", "-r",
+        help="Repo path for branch auto-detection"),
+    remote: Optional[str] = typer.Option(None, "--remote", help="Server URL override"),
+    project: Optional[str] = typer.Option(None, "--project", help="Project ID"),
+    branch: Optional[str] = typer.Option(None, "--branch", help="Branch name"),
+    depth: int = typer.Option(3, "--depth", help="Blast radius traversal depth"),
+    output_json: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    """Show blast radius of all symbols changed in a diff.
+
+    Reads a unified diff from a file argument or stdin.
+
+    Examples:
+
+        git diff HEAD~1 | ravmem diff-impact --project my-proj
+
+        ravmem diff-impact changes.patch --project my-proj --branch main
+    """
+    import json
+    if not project:
+        typer.echo("--project is required.", err=True)
+        raise typer.Exit(1)
+
+    branch_name = _detect_branch(repo.resolve(), branch)
+
+    # Read diff
+    if diff_path:
+        diff_text = diff_path.read_text()
+    elif not sys.stdin.isatty():
+        diff_text = sys.stdin.read()
+    else:
+        typer.echo("Provide a diff file as argument or pipe it to stdin.", err=True)
+        raise typer.Exit(1)
+
+    if not diff_text.strip():
+        typer.echo("Empty diff — nothing to analyze.")
+        return
+
+    client = _get_client(remote)
+    try:
+        result = client._request(
+            "POST",
+            f"/api/projects/{project}/branches/{branch_name}/diff-impact",
+            json={"diff": diff_text, "depth": depth},
+        )
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    affected = result.get("affected", [])
+    changed_symbols = result.get("changed_symbols", [])
+
+    if not changed_symbols:
+        typer.echo("No recognizable symbols found in the diff.")
+        return
+
+    typer.echo(f"\nChanged symbols detected: {', '.join(changed_symbols)}")
+
+    if not affected:
+        typer.echo("No downstream dependents found.")
+        return
+
+    typer.echo(f"\n{len(affected)} symbol(s) would be affected:\n")
+    for node in sorted(affected, key=lambda n: n.get("depth", 0)):
+        d = node.get("depth", 0)
+        sym = node.get("symbol", {})
+        name = sym.get("name", "")
+        kind = sym.get("kind", "")
+        file = sym.get("file", "")
+        line = sym.get("line_start", "")
+        indent = "  " + "  " * d
+        location = f"{Path(file).name}:{line}" if file else ""
+        typer.echo(
+            f"{indent}depth={d}  {typer.style(name, bold=True)} ({kind})  {location}"
+        )

ravmem/cli/git_local.py

@@ -0,0 +1,131 @@
+"""CLI-side git helpers — run on the client machine, not on the server."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+class LocalGitError(Exception):
+    """Raised when a local git command fails."""
+
+
+def _run(args: list[str], cwd: Path, timeout: int = 30) -> str:
+    result = subprocess.run(
+        args, cwd=str(cwd), capture_output=True, text=True, timeout=timeout,
+    )
+    if result.returncode != 0:
+        raise LocalGitError(
+            f"git command failed: {' '.join(args)}\nstderr: {result.stderr.strip()}"
+        )
+    return result.stdout.strip()
+
+
+def rev_parse(repo_path: Path, ref: str = "HEAD") -> str:
+    """Return the full SHA for *ref*."""
+    return _run(["git", "rev-parse", ref], cwd=repo_path)
+
+
+def current_branch(repo_path: Path) -> str:
+    """Return the current branch name, or empty string if detached HEAD."""
+    try:
+        return _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=repo_path)
+    except LocalGitError:
+        return ""
+
+
+def merge_base(repo_path: Path, ref_a: str, ref_b: str) -> str:
+    """Return the merge-base commit SHA of two refs."""
+    return _run(["git", "merge-base", ref_a, ref_b], cwd=repo_path)
+
+
+def ls_files(repo_path: Path) -> list[str]:
+    """Return all file paths tracked by git (honours .gitignore, no untracked files).
+
+    Paths are relative to *repo_path*, forward-slash separated.
+    Binary files are NOT excluded here — callers filter by extension as needed.
+    """
+    out = _run(["git", "ls-files"], cwd=repo_path)
+    return [line for line in out.splitlines() if line]
+
+
+def diff_name_status(
+    repo_path: Path, base_commit: str, target: str = "HEAD",
+) -> tuple[list[str], list[str]]:
+    """Return (modified_paths, deleted_paths) between *base_commit* and *target*.
+
+    Paths are relative to *repo_path*.
+    """
+    out = _run(
+        ["git", "diff", "--name-status", base_commit, target], cwd=repo_path,
+    )
+    modified: list[str] = []
+    deleted: list[str] = []
+    for line in out.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        parts = line.split("\t", 1)
+        if len(parts) != 2:
+            continue
+        status, path = parts[0].strip(), parts[1].strip()
+        if status.startswith("D"):
+            deleted.append(path)
+        else:
+            modified.append(path)
+    return modified, deleted
+
+
+def diff_unified_per_file(
+    repo_path: Path,
+    base_commit: str,
+    target: str = "HEAD",
+    context: int = 3,
+) -> list[dict[str, str]]:
+    """Return per-file unified diffs between *base_commit* and *target*.
+
+    Each item in the returned list is::
+
+        {"path": "relative/path.py", "diff": "<unified diff text>"}
+
+    Only files with actual changes are included.
+    """
+    out = _run(
+        ["git", "diff", f"--unified={context}", base_commit, target],
+        cwd=repo_path,
+        timeout=120,
+    )
+    return _split_diff_by_file(out)
+
+
+def _split_diff_by_file(raw: str) -> list[dict[str, str]]:
+    """Split a multi-file unified diff into per-file chunks."""
+    files: list[dict[str, str]] = []
+    current_path: str | None = None
+    current_lines: list[str] = []
+
+    for line in raw.splitlines(keepends=True):
+        if line.startswith("diff --git "):
+            if current_path is not None and current_lines:
+                files.append({"path": current_path, "diff": "".join(current_lines)})
+            current_lines = [line]
+            current_path = None
+        elif line.startswith("+++ b/") and current_path is None:
+            current_path = line[6:].rstrip("\n")
+            current_lines.append(line)
+        else:
+            current_lines.append(line)
+
+    if current_path is not None and current_lines:
+        files.append({"path": current_path, "diff": "".join(current_lines)})
+
+    return files
+
+
+def is_git_repo(path: Path) -> bool:
+    """Return True if *path* is inside a git repository."""
+    result = subprocess.run(
+        ["git", "-C", str(path), "rev-parse", "--git-dir"],
+        capture_output=True, timeout=5,
+    )
+    return result.returncode == 0

ravmem/cli/impact.py

@@ -0,0 +1,106 @@
+"""ravmem impact — blast radius analysis 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 impact_cmd(
+    symbol: str = typer.Argument(..., help="Symbol name or ID to analyze"),
+    repo: Path = typer.Option(Path("."), "--repo", "-r", help="Path to the repository (used for branch auto-detection)"),
+    depth: int = typer.Option(3, "--depth", "-d", help="Max traversal depth"),
+    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:
+    """Show what breaks if you change a symbol (callers, transitively)."""
+    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:
+        # The impact API expects an MD5 symbol ID, not a name.
+        # If the argument looks like a name (not a 16-char hex ID), search for it first.
+        import re
+        symbol_id = symbol
+        if not re.fullmatch(r"[0-9a-f]{16}", symbol):
+            hits = client.search(project, branch_name, symbol, limit=1)
+            if not hits:
+                typer.echo(f"Symbol '{symbol}' not found on branch '{branch_name}'.", err=True)
+                raise typer.Exit(1)
+            symbol_id = hits[0]["symbol"]["id"]
+            resolved_name = hits[0]["symbol"]["name"]
+            if resolved_name != symbol:
+                typer.echo(f"Resolved '{symbol}' → '{resolved_name}' ({symbol_id})")
+        result = client.impact(project, branch_name, symbol_id, depth=depth)
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    affected = result.get("affected", [])
+    if not affected:
+        typer.echo(f"No dependents found for '{symbol}' on branch '{branch_name}' (nothing would break).")
+        return
+
+    typer.echo(f"\nImpact analysis for '{symbol}' on branch '{branch_name}' (depth={depth}):\n")
+    typer.echo(f"  {len(affected)} symbol(s) would be affected:\n")
+    for node in sorted(affected, key=lambda n: n.get("depth", 0)):
+        d = node.get("depth", 0)
+        sym = node.get("symbol", {})
+        name = sym.get("name", "")
+        kind = sym.get("kind", "")
+        file = sym.get("file", "")
+        line = sym.get("line_start", "")
+        indent = "  " + "  " * d
+        location = f"{Path(file).name}:{line}" if file else ""
+        typer.echo(
+            f"{indent}depth={d}  {typer.style(name, bold=True)} "
+            f"({kind})  {location}"
+        )

ravmem/cli/info.py

@@ -0,0 +1,82 @@
+"""ravmem health / metrics — server status commands."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+
+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("No server configured. Run: ravmem remote config --url <URL>", err=True)
+        raise typer.Exit(1)
+    return RavMemClient(base_url=url, api_key=api_key or None)
+
+
+def health_cmd(
+    remote: Optional[str] = typer.Option(None, "--remote", help="Server URL override"),
+    output_json: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    """Show server health status and statistics."""
+    import json
+    from rich.console import Console
+    from rich.table import Table
+    from rich import box
+
+    client = _get_client(remote)
+    try:
+        data = client._request("GET", "/health")
+    finally:
+        client.close()
+
+    if output_json:
+        typer.echo(json.dumps(data, indent=2, default=str))
+        return
+
+    console = Console()
+    t = Table(box=box.SIMPLE, show_header=False, padding=(0, 2))
+    t.add_column("Key", style="bold")
+    t.add_column("Value")
+    t.add_row("Status", data.get("status", "?"))
+    t.add_row("Version", str(data.get("version", "?")))
+    t.add_row("Uptime", f"{data.get('uptime_seconds', 0):.0f}s")
+    t.add_row("Projects", str(data.get("projects_count", "?")))
+    t.add_row("Active jobs", str(data.get("active_jobs", 0)))
+    t.add_row("Queued jobs", str(data.get("queued_jobs", 0)))
+    console.print(t)
+
+
+def metrics_cmd(
+    remote: Optional[str] = typer.Option(None, "--remote", help="Server URL override"),
+) -> None:
+    """Print Prometheus-style server metrics."""
+    import httpx
+    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("No server configured. Run: ravmem remote config --url <URL>", err=True)
+        raise typer.Exit(1)
+
+    headers = {}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    resp = httpx.get(f"{url.rstrip('/')}/api/metrics", headers=headers, timeout=10)
+    resp.raise_for_status()
+    typer.echo(resp.text)