pari-cli 0.1.4__tar.gz → 0.1.6__tar.gz

{pari_cli-0.1.4 → pari_cli-0.1.6}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: pari-cli
-Version: 0.1.4
+Version: 0.1.6
 Summary: A resilient, sandbox-first terminal coding agent engineered for high pass rates and low token burn.
 Author: PARI Contributors
 License: MIT
 Project-URL: Homepage, https://pari-cli.in
-Project-URL: Documentation, https://pari-cli.in
+Project-URL: Documentation, https://pari-cli.in/docs
 Project-URL: Repository, https://github.com/MdTanwer/pari
 Keywords: ai,coding-agent,terminal,llm,developer-tools
 Classifier: Development Status :: 3 - Alpha
@@ -67,7 +67,7 @@ The exact same frontier reasoning model (Claude 3.7 Sonnet, GPT-4o) demonstrates
 
 ## 🚀 Installation & Quick Start
 
-Official Website & Documentation: **[https://pari-cli.in](https://pari-cli.in)**
+Official Website & Documentation: **[https://pari-cli.in/docs](https://pari-cli.in/docs)**
 
 Choose your platform's installation command:
 

{pari_cli-0.1.4 → pari_cli-0.1.6}/README.md

@@ -24,7 +24,7 @@ The exact same frontier reasoning model (Claude 3.7 Sonnet, GPT-4o) demonstrates
 
 ## 🚀 Installation & Quick Start
 
-Official Website & Documentation: **[https://pari-cli.in](https://pari-cli.in)**
+Official Website & Documentation: **[https://pari-cli.in/docs](https://pari-cli.in/docs)**
 
 Choose your platform's installation command:
 

{pari_cli-0.1.4 → pari_cli-0.1.6}/pari/__init__.py

@@ -1,3 +1,3 @@
 """PARI — High-performance terminal coding agent."""
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"

{pari_cli-0.1.4 → pari_cli-0.1.6}/pari/agent/loop.py

@@ -28,7 +28,8 @@ from pari.context.chunks import ContextChunk, ContextTier, assemble_context
 from pari.context.compaction import compact_context
 from pari.edit.diff import generate_unified_diff
 from pari.fs.path import resolve_safe_path
-from pari.providers.base import ModelResponse, ToolCall
+from pari.providers.message import ToolCall
+from pari.providers.response import ModelResponse
 from pari.session.logger import SessionLogger
 from pari.session.undo import GuardedUndoManager
 

{pari_cli-0.1.4 → pari_cli-0.1.6}/pari/agent/runtime.py

@@ -24,7 +24,10 @@ from pari.agent.loop import AgentExecutionLoop, TurnResult
 from pari.agent.reflection import ReflectionManager
 from pari.intelligence.repomap import RepoMapGenerator
 from pari.providers import get_provider
-from pari.providers.base import LLMProvider, ModelResponse, ProviderMessage, ToolCall
+from pari.providers.base import LLMProvider
+from pari.providers.exceptions import ProviderError
+from pari.providers.message import ProviderMessage, ToolCall
+from pari.providers.response import ModelResponse
 from pari.routing.router import DualModelRouter, router_for
 from pari.session.events import SessionEventType
 from pari.session.logger import SessionLogger
@@ -133,15 +136,33 @@ class AgentRuntime:
             self.pinned_files.append(clean_rel)
         return True
 
-    async def continue_turn(self) -> str:
+    async def continue_turn(
+        self,
+        on_tool_call: Callable[[str, dict[str, Any]], None] | None = None,
+        on_diff: Callable[[str, str], None] | None = None,
+        on_tool_result: Callable[[ToolCall, str], None] | None = None,
+        on_step_text: Callable[[str], None] | None = None,
+        on_delta: Callable[[str], None] | None = None,
+    ) -> str:
         """Run another block of turns after the user chooses Continue."""
-        return await self.execute_turn("Continue.", max_turns=TURN_EXTENSION)
+        return await self.execute_turn(
+            "Continue.",
+            on_tool_call=on_tool_call,
+            on_diff=on_diff,
+            on_tool_result=on_tool_result,
+            on_step_text=on_step_text,
+            on_delta=on_delta,
+            max_turns=TURN_EXTENSION,
+        )
 
     async def execute_turn(
         self,
         prompt: str,
         on_tool_call: Callable[[str, dict[str, Any]], None] | None = None,
         on_diff: Callable[[str, str], None] | None = None,
+        on_tool_result: Callable[[ToolCall, str], None] | None = None,
+        on_step_text: Callable[[str], None] | None = None,
+        on_delta: Callable[[str], None] | None = None,
         *,
         max_turns: int | None = None,
     ) -> str:
@@ -168,6 +189,7 @@ class AgentRuntime:
                 schemas,
                 prompt=prompt,
                 active_files=self.pinned_files,
+                on_delta=on_delta,
             )
             # Drop tool calls that were cut off so the next step cannot rerun them.
             calls = [] if is_length_stop(resp.stop_reason) else list(resp.tool_calls)
@@ -175,6 +197,16 @@ class AgentRuntime:
                 if not call.id:
                     call.id = f"call_{index}"
             self._tool_followup = bool(calls)
+            # Show the note that introduces this tool batch. The final answer
+            # has no tool calls and is printed once, after the turn returns.
+            # Deltas already painted this text. Printing it again would repeat it.
+            if (
+                calls
+                and resp.text.strip()
+                and on_step_text is not None
+                and on_delta is None
+            ):
+                on_step_text(resp.text)
             self.messages.append(
                 ProviderMessage(
                     role="assistant",
@@ -188,6 +220,8 @@ class AgentRuntime:
             self.messages.append(
                 ProviderMessage(role="tool", content=text, tool_call_id=call.id)
             )
+            if on_tool_result is not None:
+                on_tool_result(call, text)
 
         dag = self.workspace / ".pari" / "sessions" / f"{self.session_id}.jsonl"
 
@@ -206,13 +240,22 @@ class AgentRuntime:
             on_diff=on_diff,
             on_warning=remember_warning,
         )
-        result = await loop.run_turn(
-            prompt,
-            step,
-            lambda response: is_length_stop(response.stop_reason),
-            active_files=self._pinned_contents(),
-            repo_map=self._repo_map(),
-        )
+        # A failed model call must not leave the prompt sitting on the transcript.
+        # The next message would otherwise resend a turn the provider never answered.
+        sent = len(self.messages)
+        try:
+            result = await loop.run_turn(
+                prompt,
+                step,
+                lambda response: is_length_stop(response.stop_reason),
+                active_files=self._pinned_contents(),
+                repo_map=self._repo_map(),
+            )
+        except ProviderError:
+            self._tool_followup = False
+            if len(self.messages) == sent + 1 and self.messages[-1].role == "user":
+                self.messages.pop()
+            raise
         turn_record = {
             "event": "turn_complete",
             "session_id": self.session_id,

{pari_cli-0.1.4 → pari_cli-0.1.6}/pari/agent/subagent.py

@@ -35,9 +35,8 @@ class FiberSubagentPool:
         self.max_concurrency = max_concurrency
         self._slots = asyncio.Semaphore(max_concurrency)
 
-    async def run_task(self, task_id: str, coro: Coroutine) -> Any:
+    async def run_task(self, _task_id: str, coro: Coroutine) -> Any:
         """Run one research task, waiting if the pool is already full."""
-        _ = task_id
         async with self._slots:
             return await coro
 

{pari_cli-0.1.4 → pari_cli-0.1.6}/pari/auth/account.py

@@ -1,14 +1,14 @@
 """Account sign-in for providers that have a browser or device login.
 
 OpenAI, Anthropic, and OpenRouter open a browser and accept the redirect URL
-if the local callback does not finish. Grok uses a device code. DeepSeek has
-no account login, so that path does not ask for a token. Radius is not a
-provider.
+if the local callback does not finish. Grok uses a device code. A provider
+with ``account=False`` has no account login. Radius is not a provider.
 """
 
 import base64
 import errno
 import hashlib
+import html
 import json
 import re
 import secrets
@@ -22,7 +22,7 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from typing import Protocol
 
 from pari.auth.login import sign_in
-from pari.auth.providers import ProviderInfo, get_info
+from pari.auth.providers import ProviderInfo, get_info, no_account_message
 from pari.auth.store import AuthStore
 
 
@@ -35,6 +35,8 @@ class AccountUI(Protocol):
 
     def read_line(self, prompt: str) -> str | None: ...
 
+    def read_secret(self, prompt: str) -> str | None: ...
+
     def show_auth_url(
         self,
         url: str,
@@ -47,6 +49,8 @@ class AccountUI(Protocol):
 
     def sleep(self, seconds: float) -> bool: ...
 
+    def progress(self, message: str) -> None: ...
+
     def show_error(self, message: str) -> None: ...
 
 
@@ -68,6 +72,7 @@ _ANTHROPIC_SCOPES = (
     "org:create_api_key user:profile user:inference "
     "user:sessions:claude_code user:mcp_servers user:file_upload"
 )
+_CALLBACK_PATH = "/callback"
 _ANTHROPIC_COPY_REDIRECT = "https://platform.claude.com/oauth/code/callback"
 
 _OPENROUTER_AUTHORIZE = "https://openrouter.ai/auth"
@@ -89,11 +94,8 @@ _BROWSER = (
 def sign_in_account(provider_id: str, ui: AccountUI, store: AuthStore) -> str:
     """Run that provider's account login and store the credential."""
     info = get_info(provider_id)
-    if info.id == "deepseek":
-        raise ValueError(
-            "DeepSeek has no account sign-in. "
-            "Use pari-cli login deepseek --api-key <key>."
-        )
+    if not info.account:
+        raise ValueError(no_account_message(info))
     if info.id == "openai":
         cred = _login_openai(ui, store)
     elif info.id == "anthropic":
@@ -176,9 +178,7 @@ def _login_openai(ui: AccountUI, store: AuthStore) -> dict:
         code, client_id = _code_from(server, pasted, _OPENAI_REDIRECT, state)
         if not client_id:
             raise ValueError("Paste the full callback URL from the browser.")
-        ui_progress = getattr(ui, "progress", None)
-        if ui_progress:
-            ui_progress("Exchanging authorization code for tokens...")
+        ui.progress("Exchanging authorization code for tokens...")
         return _exchange_openai(code, verifier, client_id)
     finally:
         server.close()
@@ -196,7 +196,7 @@ def _login_anthropic(ui: AccountUI) -> dict:
         return _anthropic_copy_code(ui, verifier, challenge)
     server = _anthropic_server(verifier)
     redirect = (
-        server.redirect_uri if server else (f"http://localhost:53692{_callback_path()}")
+        server.redirect_uri if server else f"http://localhost:53692{_CALLBACK_PATH}"
     )
     try:
         url = _anthropic_url(challenge, verifier, redirect)
@@ -512,20 +512,18 @@ def _anthropic_url(challenge: str, state: str, redirect: str) -> str:
 
 def _anthropic_server(state: str) -> "CallbackServer | None":
     try:
-        return _listen("127.0.0.1", 53692, "/callback", "localhost", state, "Anthropic")
+        return _listen(
+            "127.0.0.1", 53692, _CALLBACK_PATH, "localhost", state, "Anthropic"
+        )
     except OSError as exc:
         if exc.errno != errno.EADDRINUSE:
             return None
     try:
-        return _listen("127.0.0.1", 0, "/callback", "localhost", state, "Anthropic")
+        return _listen("127.0.0.1", 0, _CALLBACK_PATH, "localhost", state, "Anthropic")
     except OSError:
         return None
 
 
-def _callback_path() -> str:
-    return "/callback"
-
-
 class CallbackServer:
     """Loopback redirect. OpenAI's port stays 1455 because the redirect is fixed."""
 
@@ -620,7 +618,8 @@ def _listen(
 
 def _send(request: BaseHTTPRequestHandler, status: int, message: str) -> None:
     body = (
-        f"<!doctype html><meta charset=utf-8><title>PARI</title><p>{_html(message)}</p>"
+        "<!doctype html><meta charset=utf-8><title>PARI</title>"
+        f"<p>{html.escape(message)}</p>"
     ).encode()
     request.send_response(status)
     request.send_header("Content-Type", "text/html; charset=utf-8")
@@ -654,6 +653,9 @@ def _request(url: str, data: bytes, content_type: str) -> tuple[int, dict]:
             return response.status, _json_body(response.read())
     except urllib.error.HTTPError as exc:
         return exc.code, _json_body(exc.read())
+    except (urllib.error.URLError, TimeoutError):
+        host = urllib.parse.urlparse(url).netloc
+        raise RuntimeError(f"Could not reach {host}. Check your connection.") from None
 
 
 def _json_body(raw: bytes) -> dict:
@@ -725,7 +727,3 @@ def _http_error(action: str, status: int, body: dict) -> str:
         detail = detail.get("message")
     suffix = f": {detail}" if isinstance(detail, str) and detail else ""
     return f"{action} failed (HTTP {status}){suffix}."
-
-
-def _html(text: str) -> str:
-    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")

pari_cli-0.1.6/pari/auth/credential.py

@@ -0,0 +1,128 @@
+"""Validated input for ``sign_in``."""
+
+import re
+from typing import Literal
+
+from pydantic import BaseModel, ValidationError, field_validator, model_validator
+
+from pari.auth.providers import PROVIDERS, ProviderInfo, get_info, no_account_message
+
+
+_KEY_CHARS = re.compile(r"[A-Za-z0-9_-]+")
+_MIN_API_KEY = 20
+MAX_API_KEY_LENGTH = 256
+
+
+class SignInInput(BaseModel):
+    """One sign-in request. Fields are checked in declaration order."""
+
+    method: Literal["api_key", "account"]
+    provider_id: str
+    secret: str
+    refresh: str | None = None
+    client_id: str | None = None
+    expires: int | None = None
+
+    @property
+    def info(self) -> ProviderInfo:
+        return get_info(self.provider_id)
+
+    @field_validator("method", mode="before")
+    @classmethod
+    def _method(cls, value: object) -> object:
+        if value not in ("api_key", "account"):
+            raise ValueError("Sign in with an API key or an account token.")
+        return value
+
+    @field_validator("provider_id")
+    @classmethod
+    def _provider(cls, value: str) -> str:
+        return get_info(value).id
+
+    @field_validator("secret")
+    @classmethod
+    def _secret(cls, value: str) -> str:
+        token = value.strip()
+        if not token:
+            raise ValueError("The credential is empty.")
+        return token
+
+    @field_validator("refresh", "client_id", mode="before")
+    @classmethod
+    def _optional_text(cls, value: object) -> str | None:
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+        return None
+
+    @field_validator("expires", mode="before")
+    @classmethod
+    def _optional_int(cls, value: object) -> int | None:
+        return value if isinstance(value, int) else None
+
+    @model_validator(mode="after")
+    def _check_credential(self) -> "SignInInput":
+        if self.method == "account" and not self.info.account:
+            raise ValueError(no_account_message(self.info))
+        if self.method == "api_key":
+            _check_api_key(self.info, self.secret)
+        return self
+
+
+def parse_sign_in(
+    provider_id: str,
+    secret: str,
+    method: str,
+    extra: dict | None = None,
+) -> SignInInput:
+    """Validate the input. Raises ``ValueError`` with a message to show as is."""
+    extra = extra or {}
+    try:
+        return SignInInput.model_validate(
+            {
+                "method": method,
+                "provider_id": provider_id,
+                "secret": secret,
+                "refresh": extra.get("refresh"),
+                "client_id": extra.get("client_id"),
+                "expires": extra.get("expires"),
+            }
+        )
+    except ValidationError as exc:
+        raise ValueError(_message(exc)) from None
+
+
+def _message(exc: ValidationError) -> str:
+    """The first error as a sentence. Rule failures carry their own text."""
+    error = exc.errors()[0]
+    if error["type"] == "value_error":
+        return str(error["ctx"]["error"])
+    return f"{error['loc'][0]}: {error['msg']}"
+
+
+def _check_api_key(info: ProviderInfo, token: str) -> None:
+    if any(char.isspace() for char in token):
+        raise ValueError(f"{info.label} API keys cannot contain spaces.")
+    _check_prefix(info, token)
+    if not _KEY_CHARS.fullmatch(token):
+        raise ValueError(
+            f"That {info.label} API key uses characters that are not allowed."
+        )
+    if len(token) < _MIN_API_KEY:
+        raise ValueError(f"That {info.label} API key is too short.")
+    if len(token) > MAX_API_KEY_LENGTH:
+        raise ValueError(f"That {info.label} API key is too long.")
+
+
+def _check_prefix(info: ProviderInfo, token: str) -> None:
+    """The most specific prefix wins, so ``sk-ant-`` is Anthropic and not OpenAI."""
+    matches = [item for item in PROVIDERS if token.startswith(item.key_prefix)]
+    if not matches:
+        raise ValueError(f"{info.label} API keys start with {info.key_prefix}.")
+    longest = max(len(item.key_prefix) for item in matches)
+    owners = [item for item in matches if len(item.key_prefix) == longest]
+    if info not in owners:
+        names = " or ".join(item.label for item in owners)
+        raise ValueError(
+            f"That key belongs to {names}. "
+            f"{info.label} keys start with {info.key_prefix}."
+        )

{pari_cli-0.1.4 → pari_cli-0.1.6}/pari/auth/interactive.py

@@ -2,7 +2,6 @@
 
 import base64
 import ctypes
-import getpass
 import os
 import select
 import sys
@@ -22,7 +21,7 @@ except ImportError:
     tty = None
 
 from pari.auth.account import AccountUI, LoginCancelled, sign_in_account
-from pari.auth.login import sign_in, sign_out, status_text
+from pari.auth.login import KeyVerifier, sign_in, sign_out, status_text
 from pari.auth.menu import (
     API_KEY_TITLE,
     LOGOUT_TITLE,
@@ -34,8 +33,10 @@ from pari.auth.menu import (
     provider_rows,
     signed_in_rows,
 )
-from pari.auth.providers import ProviderInfo, get_info
+from pari.auth.providers import ProviderInfo, get_info, no_account_message
+from pari.auth.secret_field import SecretField
 from pari.auth.store import AuthStore
+from pari.auth.verify import verify_api_key
 
 
 _ACCENT = "\033[38;2;255;121;198m"
@@ -44,12 +45,15 @@ _WARN = "\033[38;2;230;180;80m"
 _OK = "\033[38;2;80;200;120m"
 _BOLD = "\033[1m"
 _RESET = "\033[0m"
+_PASTE_ON = "\033[?2004h"
+_PASTE_OFF = "\033[?2004l"
 
 
 def run_login(
     ui: AccountUI,
     store: AuthStore | None = None,
     provider_id: str | None = None,
+    verify: KeyVerifier | None = None,
 ) -> str:
     """Walk the menus and return the success sentence. Empty means cancelled."""
     auth = store or AuthStore()
@@ -62,7 +66,7 @@ def run_login(
             return ""
         kind = "account" if method == METHOD_ACCOUNT else "api_key"
         if provider_id:
-            message = _finish(kind, provider_id, ui, auth)
+            message = _finish(kind, provider_id, ui, auth, verify)
             if message is None:
                 continue
             return message
@@ -70,7 +74,7 @@ def run_login(
             chosen = ui.choose_provider(kind, provider_rows(kind, auth))
             if not chosen:
                 break
-            message = _finish(kind, chosen, ui, auth)
+            message = _finish(kind, chosen, ui, auth, verify)
             if message is None:
                 continue
             return message
@@ -121,7 +125,7 @@ def login_tty(provider_id: str | None = None) -> int:
         return 0
     ui = TerminalLogin()
     try:
-        message = run_login(ui, provider_id=provider_id)
+        message = run_login(ui, provider_id=provider_id, verify=verify_api_key)
     except KeyboardInterrupt:
         return 0
     except (ValueError, RuntimeError) as exc:
@@ -134,31 +138,39 @@ def login_tty(provider_id: str | None = None) -> int:
     return 0
 
 
-def _finish(kind: str, provider_id: str, ui: AccountUI, store: AuthStore) -> str | None:
+def _finish(
+    kind: str,
+    provider_id: str,
+    ui: AccountUI,
+    store: AuthStore,
+    verify: KeyVerifier | None,
+) -> str | None:
     info = get_info(provider_id)
     try:
         if kind == "api_key":
-            return _read_api_key(ui, info, store)
-        if info.id == "deepseek":
-            ui.show_error(
-                "DeepSeek has no account sign-in. "
-                "Use pari-cli login deepseek --api-key <key>."
-            )
+            return _read_api_key(ui, info, store, verify)
+        if not info.account:
+            ui.show_error(no_account_message(info))
             return None
         return sign_in_account(info.id, ui, store)
     except LoginCancelled:
         return None
 
 
-def _read_api_key(ui: AccountUI, info: ProviderInfo, store: AuthStore) -> str:
-    """Ask until the key matches that provider, or the user cancels."""
+def _read_api_key(
+    ui: AccountUI,
+    info: ProviderInfo,
+    store: AuthStore,
+    verify: KeyVerifier | None,
+) -> str:
+    """Ask until the provider accepts the key, or the user cancels."""
     prompt = f"Enter your {info.label} API key:"
     while True:
         secret = ui.read_secret(prompt)
         if secret is None:
             raise LoginCancelled()
         try:
-            return sign_in(info.id, secret, "api_key", store)
+            return sign_in(info.id, secret, "api_key", store, verify=verify)
         except ValueError as exc:
             ui.show_error(str(exc))
 
@@ -188,14 +200,25 @@ class TerminalLogin:
         return self._run(ProviderMenu(rows, search=search, title=title))
 
     def read_secret(self, prompt: str) -> str | None:
+        """Read a key shown as ``x`` per character. None means cancelled."""
         self._leave()
+        # The alternate screen restores the cursor onto the previous prompt.
+        sys.stdout.write("\n" + _PASTE_ON)
+        field = SecretField()
         try:
-            # The alternate screen restores the cursor onto the previous prompt.
-            sys.stdout.write("\n")
+            self._enter_raw()
+            while True:
+                sys.stdout.write(f"\r\033[K{prompt} {field.masked}")
+                sys.stdout.flush()
+                result = field.on_key(self._key(None))
+                if result == "cancel":
+                    return None
+                if result == "enter":
+                    return field.value
+        finally:
+            sys.stdout.write(_PASTE_OFF + "\n")
             sys.stdout.flush()
-            return getpass.getpass(prompt + " ")
-        except (KeyboardInterrupt, EOFError):
-            return None
+            self._leave()
 
     def show_error(self, message: str) -> None:
         self._leave()
@@ -293,6 +316,9 @@ class TerminalLogin:
             sys.stdout.write("\033[?1049h\033[?25l")
             sys.stdout.flush()
             self._alt = True
+        self._enter_raw()
+
+    def _enter_raw(self) -> None:
         if self._raw:
             return
         self._fd = sys.stdin.fileno()
@@ -506,6 +532,10 @@ def _normalize(raw: bytes) -> str:
         return "cancel"
     if raw == b"\x18":
         return "copy"
+    if raw == b"\x1b[200~":
+        return "paste_start"
+    if raw == b"\x1b[201~":
+        return "paste_end"
     if raw == b"\x1b":
         return "cancel"
     if raw.startswith(b"\x1b[") or (raw.startswith(b"\x1bO") and len(raw) >= 3):