aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/apps/cli/release_download.py

@@ -0,0 +1,159 @@
+"""Bounded, resumable release transfers. Activation still verifies the digest."""
+from __future__ import annotations
+
+from contextlib import contextmanager
+import http.client
+import json
+import os
+from pathlib import Path
+import re
+import sys
+import time
+import urllib.error
+import urllib.request
+
+
+class DownloadTimeout(TimeoutError):
+    pass
+
+
+@contextmanager
+def _lock(path: Path):
+    # Native downloads run on macOS/Linux; flock releases on process exit,
+    # including Ctrl+C. Do not let two updates append to the same partial file.
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(str(path), os.O_CREAT | os.O_RDWR | getattr(os, "O_NOFOLLOW", 0), 0o600)
+    try:
+        try:
+            if os.name == "nt":
+                import msvcrt
+
+                if not os.fstat(fd).st_size:
+                    os.write(fd, b"0")
+                os.lseek(fd, 0, os.SEEK_SET)
+                msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as exc:
+            raise RuntimeError("Another update is downloading this release; wait for it to finish") from exc
+        yield
+    finally:
+        os.close(fd)
+
+
+def download(url: str, target: Path, *, deadline_seconds: float = 300,
+             attempts: int = 3, progress=None) -> None:
+    """Keep a partial across attempts/runs; resume only a validated byte range.
+
+    A server ignoring Range starts a fresh file. Invalid Content-Range, changed
+    total size or contradictory validators are never appended. Read in single
+    socket-buffer chunks so a trickle cannot evade the total deadline.
+    """
+    target = Path(target)
+    part = target.with_name(target.name + ".part")
+    state = target.with_name(target.name + ".part.json")
+    limit = time.monotonic() + deadline_seconds
+    last_progress = 0.0
+
+    def report(received, total, complete=False):
+        nonlocal last_progress
+        now = time.monotonic()
+        if not complete and now - last_progress < 1:
+            return
+        last_progress = now
+        if progress:
+            progress(received, total)
+        elif sys.stderr.isatty():
+            size = f"{received / 1048576:.1f} MiB"
+            if total:
+                size += f" / {total / 1048576:.1f} MiB ({min(100, received * 100 // total)}%)"
+            print(f"\rDownloading {target.name}: {size}", end="\n" if complete else "", file=sys.stderr, flush=True)
+
+    with _lock(target.with_name(target.name + ".lock")):
+        try:
+            metadata = json.loads(state.read_text())
+        except (OSError, ValueError):
+            metadata = {}
+        if metadata.get("url") != url:
+            part.unlink(missing_ok=True)
+            metadata = {"url": url}
+        for attempt in range(attempts):
+            left = limit - time.monotonic()
+            if left <= 0:
+                raise DownloadTimeout("Download exceeded its total deadline; partial retained for the next update")
+            offset = part.stat().st_size if part.is_file() else 0
+            headers = {"User-Agent": "aria-code-updater", "Accept": "*/*", "Accept-Encoding": "identity"}
+            if offset:
+                headers["Range"] = f"bytes={offset}-"
+                if metadata.get("validator"):
+                    headers["If-Range"] = metadata["validator"]
+            try:
+                request = urllib.request.Request(url, headers=headers)
+                with urllib.request.urlopen(request, timeout=min(15, left)) as response:
+                    response_headers = getattr(response, "headers", {})
+                    status = getattr(response, "status", 200)
+                    etag = response_headers.get("ETag", "")
+                    validator = (etag if etag and not etag.startswith("W/") else response_headers.get("Last-Modified"))
+                    total = None
+                    mode = "wb"
+                    if status == 206:
+                        match = re.fullmatch(r"bytes (\d+)-(\d+)/(\d+)", response_headers.get("Content-Range", ""))
+                        if not match or int(match[1]) != offset or int(match[2]) < offset:
+                            raise ValueError("Release server returned an invalid resume range")
+                        total = int(match[3])
+                        if int(match[2]) >= total or (metadata.get("total") and metadata["total"] != total):
+                            raise ValueError("Release size changed during a resumed download")
+                        if metadata.get("validator") and validator and metadata["validator"] != validator:
+                            raise ValueError("Release changed during a resumed download")
+                        mode = "ab"
+                    else:
+                        offset = 0
+                        length = response_headers.get("Content-Length")
+                        total = int(length) if length else None
+                    metadata = {"url": url, "validator": validator, "total": total}
+                    state.write_text(json.dumps(metadata))
+                    received = offset
+                    with part.open(mode) as output:
+                        reader = getattr(response, "read1", response.read)
+                        while True:
+                            if time.monotonic() >= limit:
+                                raise DownloadTimeout("Download exceeded its total deadline; partial retained")
+                            chunk = reader(65536)
+                            if time.monotonic() >= limit:
+                                raise DownloadTimeout("Download exceeded its total deadline; partial retained")
+                            if not chunk:
+                                break
+                            output.write(chunk)
+                            received += len(chunk)
+                            report(received, total)
+                    if total is not None and received != total:
+                        raise OSError("Incomplete release transfer")
+                    os.replace(part, target)
+                    state.unlink(missing_ok=True)
+                    report(received, total, True)
+                    return
+            except urllib.error.HTTPError as exc:
+                if exc.code == 416:
+                    # A stale/complete partial is not trusted as a completed
+                    # response. Re-fetch it; the outer installer checks its hash.
+                    part.unlink(missing_ok=True)
+                    state.unlink(missing_ok=True)
+                    metadata = {"url": url}
+                elif exc.code not in {408, 429, 500, 502, 503, 504}:
+                    raise
+                if attempt + 1 == attempts:
+                    raise
+            except DownloadTimeout:
+                raise
+            except ValueError:
+                part.unlink(missing_ok=True)
+                state.unlink(missing_ok=True)
+                raise
+            except (OSError, urllib.error.URLError, http.client.HTTPException):
+                if attempt + 1 == attempts:
+                    raise
+            delay = min(2 ** attempt, max(0, limit - time.monotonic()))
+            time.sleep(delay)
+        raise OSError("Release download did not complete")

aria_code/apps/cli/review_runner.py

@@ -0,0 +1,111 @@
+"""Run review_service against the configured model, interactively or headless.
+
+    aria-code review                       # uncommitted changes, tracked and untracked
+    aria-code review --base main           # everything since the merge base with main
+    aria-code review --commit HEAD~1
+    aria-code review --staged --json --fail-on P1     # for CI
+
+Exit codes: 0 reviewed (nothing at or above --fail-on), 1 findings at or above
+--fail-on, 2 the review could not run or the reviewer did not answer in the
+expected format while --fail-on was set — a gate must not pass on a review
+that did not happen.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+from aria_code import review_service as rs
+
+
+def make_model_call(config: dict, model: str | None = None) -> rs.ModelCall:
+    """One isolated completion through the provider Aria is configured for — no tools."""
+    from aria_code.apps.cli.providers.base import ConfiguredProvider, event_kind
+
+    chosen = model or config.get("review_model") or config.get("model") or ""
+    if not chosen:
+        raise rs.ReviewError("no model configured; set one with /model or --model")
+
+    async def call(messages: list) -> str:
+        provider = ConfiguredProvider(config, chosen)
+        text = ""
+        async for event in provider.stream(messages, tools=[]):
+            if event_kind(event) == "LLMToken":
+                text += event.text
+            elif event_kind(event) == "LLMDone":
+                if not event.success:
+                    raise rs.ReviewError(f"{chosen}: {event.error or 'the model call failed'}")
+                return event.response or text
+        return text
+
+    return call
+
+
+def _load_config() -> dict:
+    from aria_code.apps.cli.bootstrap import (default_config, load_aria_env, prepare_network, runtime_paths,
+                                              use_macos_ca_bundle, use_system_trust_store)
+    from aria_code.apps.cli.config_store import load_cli_config
+
+    # The same environment the interactive CLI starts with: keys from ~/.aria/.env,
+    # a working proxy (or none), and the system's TLS trust store.
+    try:
+        load_aria_env()
+        prepare_network()
+        if not use_system_trust_store():
+            use_macos_ca_bundle()
+    except Exception:
+        pass
+    return load_cli_config(runtime_paths(), default_config())
+
+
+def run_headless(argv: list[str], *, model_call: rs.ModelCall | None = None,
+                 config: dict | None = None, out=None) -> int:
+    out = out or sys.stdout
+    parser = argparse.ArgumentParser(prog="aria-code review", description="Review a code change.")
+    scope = parser.add_mutually_exclusive_group()
+    scope.add_argument("--staged", action="store_true", help="review staged changes only")
+    scope.add_argument("--base", metavar="BRANCH", help="review everything since the merge base with BRANCH")
+    scope.add_argument("--commit", metavar="SHA", help="review one commit")
+    scope.add_argument("--file", metavar="PATH", help="review one whole file")
+    parser.add_argument("--json", action="store_true", help="print the review as JSON")
+    parser.add_argument("--fail-on", metavar="P0|P1|P2|P3",
+                        help="exit 1 when a finding on the change is at this priority or above")
+    parser.add_argument("--model", help="model to review with (default: review_model, then model)")
+    parser.add_argument("--lang", choices=["en", "zh"], help="language of the review text")
+    parser.add_argument("--max-chars", type=int, default=rs.DEFAULT_MAX_CHARS)
+    parser.add_argument("--cwd", default=".", help="repository to review (default: current directory)")
+    args = parser.parse_args(argv)
+
+    try:
+        threshold = rs.parse_priority(args.fail_on) if args.fail_on else None
+    except ValueError as exc:
+        parser.error(str(exc))
+
+    target = (rs.ReviewTarget("staged") if args.staged else rs.ReviewTarget("base", args.base) if args.base
+              else rs.ReviewTarget("commit", args.commit) if args.commit
+              else rs.ReviewTarget("file", args.file) if args.file else rs.ReviewTarget("uncommitted"))
+    try:
+        inp = rs.collect(target, Path(args.cwd), max_chars=args.max_chars)
+        if config is None:
+            config = _load_config()
+        lang = args.lang or ("zh" if str(config.get("ui_lang", "en")).lower().startswith("zh") else "en")
+        call = model_call or make_model_call(config, args.model)
+        result = asyncio.run(rs.run_review(inp, call, lang=lang))
+    except rs.ReviewError as exc:
+        print(f"aria-code review: {exc}", file=sys.stderr)
+        return 2
+
+    out.write((json.dumps(result.to_dict(), ensure_ascii=False, indent=2) if args.json
+               else rs.render_text(result, lang=lang)) + "\n")
+    if threshold is None:
+        return 0
+    if not result.structured:
+        print("aria-code review: the reviewer's reply was not a structured review; failing the gate",
+              file=sys.stderr)
+        return 2
+    worst = result.worst_priority()
+    return 1 if worst is not None and worst <= threshold else 0