rio-cli 0.1.0__tar.gz

rio_cli-0.1.0/.gitignore

@@ -0,0 +1,45 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# Dependencies
+node_modules
+.pnp
+.pnp.js
+
+# Local env files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Testing
+coverage
+
+# Turbo
+.turbo
+
+# Vercel
+.vercel
+
+# Build Outputs
+.next/
+out/
+build
+dist
+
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Misc
+.DS_Store
+*.pem
+.venv/
+__pycache__/
+*.pyc
+
+tsconfig.tsbuildinfo
+
+.config/

rio_cli-0.1.0/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, JayTheCoder77
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

rio_cli-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.5
+Name: rio-cli
+Version: 0.1.0
+Summary: Command-line client for Rio, an automated code review tool.
+Project-URL: Homepage, https://github.com/JayTheCoder77/rio
+Project-URL: Repository, https://github.com/JayTheCoder77/rio
+Author: JayTheCoder77
+License-Expression: ISC
+License-File: LICENSE
+Requires-Python: <3.13,>=3.12
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=15.0.0
+Requires-Dist: rio-review-core<0.2.0,>=0.1.0
+Requires-Dist: typer>=0.27.1
+Description-Content-Type: text/markdown
+
+# rio-cli
+
+The command-line client for [Rio](https://github.com/JayTheCoder77/rio), an automated
+code review tool. Review your local diffs from the terminal, backed by the same
+AI review engine used by Rio's GitHub App.
+
+## Installation
+
+```sh
+pip install rio-cli
+```
+
+This installs the `rio` command.
+
+## Usage
+
+```sh
+# Review currently staged changes
+rio review --staged
+
+# Review uncommitted changes (staged + unstaged)
+rio review --uncommitted
+
+# Review the last commit
+rio review --committed
+
+# Review a diff from a file
+rio review --diff path/to.diff
+
+# Include untracked files alongside any of the above
+rio review --staged --include-untracked
+```
+
+## Configuration
+
+Rio reads `~/.config/rio/config.toml` for the AI engine URL and API key:
+
+```toml
+[api]
+url = "https://your-rio-instance.example.com"
+api_key = "your-api-key"
+```
+
+If no config file is found, the CLI defaults to `http://localhost:8000` for local
+development against a self-hosted `ai-engine`.
+
+## License
+
+[ISC](LICENSE) © 2026 JayTheCoder77

rio_cli-0.1.0/README.md

@@ -0,0 +1,49 @@
+# rio-cli
+
+The command-line client for [Rio](https://github.com/JayTheCoder77/rio), an automated
+code review tool. Review your local diffs from the terminal, backed by the same
+AI review engine used by Rio's GitHub App.
+
+## Installation
+
+```sh
+pip install rio-cli
+```
+
+This installs the `rio` command.
+
+## Usage
+
+```sh
+# Review currently staged changes
+rio review --staged
+
+# Review uncommitted changes (staged + unstaged)
+rio review --uncommitted
+
+# Review the last commit
+rio review --committed
+
+# Review a diff from a file
+rio review --diff path/to.diff
+
+# Include untracked files alongside any of the above
+rio review --staged --include-untracked
+```
+
+## Configuration
+
+Rio reads `~/.config/rio/config.toml` for the AI engine URL and API key:
+
+```toml
+[api]
+url = "https://your-rio-instance.example.com"
+api_key = "your-api-key"
+```
+
+If no config file is found, the CLI defaults to `http://localhost:8000` for local
+development against a self-hosted `ai-engine`.
+
+## License
+
+[ISC](LICENSE) © 2026 JayTheCoder77

rio_cli-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "rio-cli"
+version = "0.1.0"
+description = "Command-line client for Rio, an automated code review tool."
+readme = "README.md"
+license = "ISC"
+authors = [{ name = "JayTheCoder77" }]
+requires-python = ">=3.12,<3.13"
+dependencies = [
+    "rio-review-core>=0.1.0,<0.2.0",
+    "httpx>=0.28.1",
+    "rich>=15.0.0",
+    "typer>=0.27.1",
+    "pyyaml>=6.0"
+]
+
+[project.scripts]
+rio = "rio_cli.main:app"
+
+[project.urls]
+Homepage = "https://github.com/JayTheCoder77/rio"
+Repository = "https://github.com/JayTheCoder77/rio"
+
+[tool.uv.sources]
+rio-review-core = { workspace = true }
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["rio_cli"]
+
+[tool.hatch.build.targets.sdist]
+include = ["rio_cli", "README.md", "LICENSE"]

rio_cli-0.1.0/rio_cli/config.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+import tomllib
+
+from rio_cli.utils import _fail
+
+DEFAULT_AI_ENGINE_URL = "http://localhost:8000"
+CONFIG_PATH = Path.home() / ".config" / "rio" / "config.toml"
+
+def get_ai_engine_url() -> str:
+    if not CONFIG_PATH.exists():
+        return DEFAULT_AI_ENGINE_URL
+
+    try:
+        with CONFIG_PATH.open("rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        _fail(f"Error : invalid config file at {CONFIG_PATH} : {e}")
+
+    url = data.get("api", {}).get("url")
+    if not url:
+        _fail(f"Error : {CONFIG_PATH} exists but has no [api] url set.")
+
+    return url
+
+def get_api_key() -> str | None:
+    if not CONFIG_PATH.exists():
+        return None
+
+    try:
+        with CONFIG_PATH.open("rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        _fail(f"Error : invalid config file at {CONFIG_PATH} : {e}")
+
+    api_key = data.get("api" , {}).get("api_key")
+    if api_key is None:
+        return None
+
+    return api_key

rio_cli-0.1.0/rio_cli/git.py

@@ -0,0 +1,90 @@
+import subprocess
+from pathlib import Path
+
+from rio_cli.utils import _fail, _run_git_diff, _try_run_git_diff
+
+
+def _get_staged_diff() -> str:
+    return _run_git_diff(["--staged"], "No staged changes found.")
+
+def _get_uncommitted_diff() -> str:
+    return _run_git_diff(["HEAD"], "No uncommitted changes found.")
+
+def _get_diff_from_file(path: str) -> str:
+    try:
+        return Path(path).read_text()
+    except FileNotFoundError:
+        _fail(f"Error: File not found : {path}")
+
+def _try_staged_diff() -> str:
+    return _try_run_git_diff(["--staged"])
+
+def _try_uncommitted_diff() -> str:
+    return _try_run_git_diff(["HEAD"])
+
+def _try_committed_diff() -> str:
+    upstream_check = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if upstream_check.returncode != 0:
+        return ""  # no upstream configured — treat as "nothing to show", not an error
+
+    upstream_ref = upstream_check.stdout.strip()
+    return _try_run_git_diff([f"{upstream_ref}...HEAD"])
+    
+def _get_committed_diff() -> str:
+    """Hard-fail variant for the explicit --committed flag."""
+    upstream_check = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if upstream_check.returncode != 0:
+        _fail("Error: no upstream branch configured — can't determine committed-but-unpushed changes.")
+
+    upstream_ref = upstream_check.stdout.strip()
+    return _run_git_diff([f"{upstream_ref}...HEAD"],"No committed (unpushed) changes found.")
+
+
+def _get_combined_diff() -> str:
+    """Default (no-flags) behavior: committed-unpushed + uncommitted, whichever exist."""
+    committed = _try_committed_diff()
+    uncommitted = _try_run_git_diff(["HEAD"])
+
+    combined = committed + uncommitted
+    if not combined.strip():
+        _fail("No committed or uncommitted changes found.")
+
+    return combined
+    
+def _get_untracked_files() -> list[str]:
+    result = subprocess.run(["git", "ls-files", "--others","--exclude-standard"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return []
+    return [line for line in result.stdout.splitlines() if line.strip()]
+
+def _get_untracked_diff() -> str:
+    """Synthetic diffs for untracked files, via git diff --no-index against /dev/null."""
+    paths = _get_untracked_files()
+    diffs = []
+    for path in paths:
+        result = subprocess.run(
+            ["git", "diff", "--no-index", "/dev/null", path],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode not in (0, 1):
+            continue  # real error for this file — skip rather than fail the whole command
+        if result.stdout.strip():
+            diffs.append(result.stdout)
+  
+    return "\n".join(diffs)

rio_cli-0.1.0/rio_cli/main.py

@@ -0,0 +1,82 @@
+import typer
+
+from rio_cli.git import (
+    _get_combined_diff,
+    _get_committed_diff,
+    _get_diff_from_file,
+    _get_staged_diff,
+    _get_uncommitted_diff,
+    _get_untracked_diff,
+    _try_committed_diff,
+    _try_staged_diff,
+    _try_uncommitted_diff,
+)
+from rio_cli.output import render_findings
+from rio_cli.post import _post_review
+from rio_cli.utils import _fail
+
+app = typer.Typer()
+
+
+@app.callback()
+def callback():
+    pass
+
+def _resolve_diff(
+    staged: bool,
+    uncommitted: bool,
+    committed: bool,
+    diff_file: str | None,
+    include_untracked: bool,
+) -> str:
+    if include_untracked:
+        # soft: let empty scopes pass through, only fail if everything (incl. untracked) is empty
+        if diff_file:
+            base = _get_diff_from_file(diff_file)
+        elif uncommitted:
+            base = _try_uncommitted_diff()
+        elif committed:
+            base = _try_committed_diff()
+        elif staged:
+            base = _try_staged_diff()
+        else:
+            base = _try_committed_diff() + _try_uncommitted_diff()
+
+        untracked = _get_untracked_diff()
+        combined = base + untracked
+        if not combined.strip():
+            _fail("No changes found (including untracked files).")
+        return combined
+
+    # hard: existing behavior, each scope fails loudly if empty
+    if diff_file:
+        return _get_diff_from_file(diff_file)
+    elif uncommitted:
+        return _get_uncommitted_diff()
+    elif committed:
+        return _get_committed_diff()
+    elif staged:
+        return _get_staged_diff()
+    else:
+        return _get_combined_diff()
+
+@app.command()
+def review(
+    staged : bool = typer.Option(False , "--staged"),
+    uncommitted: bool = typer.Option(False, "--uncommitted"),
+    committed: bool = typer.Option(False, "--committed"),
+    diff_file : str | None = typer.Option(None , "--diff"),
+    include_untracked: bool = typer.Option(False, "--include-untracked"),
+):
+    """ Print Findings for a local diff """
+    flags_set = sum([staged, uncommitted, committed, diff_file is not None])
+    if flags_set > 1:
+        _fail("Error: --staged, --uncommitted, --committed, and --diff cannot be used together.")
+  
+    diff_text = _resolve_diff(staged, uncommitted,committed, diff_file, include_untracked)
+
+    result = _post_review(diff_text)
+    render_findings(result)
+
+if __name__ == "__main__":
+    app()

rio_cli-0.1.0/rio_cli/output.py

@@ -0,0 +1,39 @@
+from collections import defaultdict
+
+from rich.console import Console
+from rich.panel import Panel
+from rio_core.models import Finding
+
+console = Console()
+
+SEVERITY_ORDER = ["critical", "warning", "info"]
+SEVERITY_COLOR = {
+    "critical": "red",
+    "warning": "yellow",
+    "info": "cyan",
+}
+
+def render_findings(findings : list[Finding]) -> None:
+    if not findings:
+        console.print("[green]No findings - looks clean.[/green]")
+        return
+    
+    grouped : dict[str, list[Finding]] = defaultdict(list)
+
+    for f in findings:
+        grouped[f.severity].append(f)
+
+    for severity in SEVERITY_ORDER:
+        group = grouped.get(severity)
+        if not group:
+            continue
+
+        color = SEVERITY_COLOR[severity]
+        console.print(f"\n[bold {color}]{severity.upper()} ({len(group)})[/bold {color}]")
+
+        for f in group:
+            console.print(Panel(
+               f"{f.message}\n\n[dim]{f.rationale}[/dim]",
+                            title=f"{f.file}:{f.line}",
+                            border_style=color,
+            ))

rio_cli-0.1.0/rio_cli/post.py

@@ -0,0 +1,35 @@
+import httpx
+from rio_core.models import Finding
+
+from rio_cli.config import get_ai_engine_url, get_api_key
+from rio_cli.rio_config import load_rio_config
+from rio_cli.utils import _fail
+
+
+def _post_review(diff_text : str) -> list[Finding]:
+    headers : dict = {}
+    api_key = get_api_key()
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    
+    rio_config = load_rio_config()
+    ai_engine_url = get_ai_engine_url()
+    try:
+        response = httpx.post(
+            f"{ai_engine_url}/v1/review",
+            json={"diff" : diff_text , "config" : rio_config.model_dump()},
+            headers=headers,
+            timeout=120.0
+        )
+    except httpx.ConnectError:
+        _fail(f"Error : could not connect to ai-engine at {ai_engine_url}.")
+    
+    except httpx.TimeoutException:
+        _fail("Error: ai-engine request timed out.")
+    
+    if response.status_code != 200:
+        _fail(f"Error: ai-engine returned {response.status_code}: {response.text}")
+    
+    data = response.json()
+    return [Finding(**f) for f in data["findings"]]
+

rio_cli-0.1.0/rio_cli/rio_config.py

@@ -0,0 +1,34 @@
+import subprocess
+from pathlib import Path
+
+import yaml
+from rio_core.config import RioConfig
+
+
+def _get_repo_root() -> Path | None:
+    result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+    return Path(result.stdout.strip())
+
+
+def load_rio_config() -> RioConfig:
+    repo_root = _get_repo_root()
+    if repo_root is None:
+        return RioConfig()
+
+    config_path = repo_root / ".rio.yml"
+    if not config_path.exists():
+        return RioConfig()
+
+    try:
+        data = yaml.safe_load(config_path.read_text())
+    except yaml.YAMLError:
+        return RioConfig()
+
+    return RioConfig(**(data or {}))

rio_cli-0.1.0/rio_cli/utils.py

@@ -0,0 +1,33 @@
+import subprocess
+from typing import NoReturn
+
+import typer
+
+
+def _fail(message : str) -> NoReturn:
+    typer.echo(message , err=True)
+    raise typer.Exit(code=1)
+
+def _try_run_git_diff(args: list[str]) -> str:
+    """Run git diff with the given args. Returns ""on any failure or empty result."""
+    try:
+        result = subprocess.run(
+            ["git", "diff", *args],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return ""
+
+    if result.returncode != 0:
+        return ""
+
+    return result.stdout
+
+def _run_git_diff(args: list[str], empty_message: str) -> str:
+    """Run git diff, hard-failing (via _fail) on any error or empty result."""
+    output = _try_run_git_diff(args)
+    if not output.strip():
+        _fail(empty_message)
+    return output