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

pari_cli-0.1.4/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: pari-cli
+Version: 0.1.4
+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: Repository, https://github.com/MdTanwer/pari
+Keywords: ai,coding-agent,terminal,llm,developer-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Requires-Dist: prompt_toolkit>=3.0.36
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.12.10; extra == "dev"
+Requires-Dist: pre-commit>=4.3.0; extra == "dev"
+Requires-Dist: pycodestyle>=2.12.0; extra == "dev"
+Provides-Extra: ast
+Requires-Dist: tree-sitter>=0.21.0; extra == "ast"
+Requires-Dist: tree-sitter-languages>=1.10.0; extra == "ast"
+Requires-Dist: networkx>=3.0; extra == "ast"
+Requires-Dist: grep-ast>=0.3.0; extra == "ast"
+Provides-Extra: cloud
+Requires-Dist: e2b>=0.14.0; extra == "cloud"
+Provides-Extra: all
+Requires-Dist: pari-cli[ast,cloud,dev]; extra == "all"
+Dynamic: license-file
+
+# PARI — Next-Generation Terminal Coding Agent
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![Architecture: 11-Layer Stack](https://img.shields.io/badge/architecture-11--layer-green.svg)](docs/architecture/overview.md)
+[![Security: Kernel Sandboxed](https://img.shields.io/badge/sandbox-bwrap%20%7C%20Seatbelt%20%7C%20E2B-orange.svg)](docs/layers/layer-0-sandboxing.md)
+
+---
+
+## ⚡ The Core Thesis
+
+$$\text{\bf Agent failure is a systems engineering failure, not a reasoning failure.}$$
+
+The exact same frontier reasoning model (Claude 3.7 Sonnet, GPT-4o) demonstrates a **15% pass rate** in a naive loop, but achieves a **50–55% pass rate** inside an engineered harness. The 35% delta is not model intelligence; it is accounted for by **six fatal systems failure modes**:
+
+1. **Unbounded stdout poisoning** $\rightarrow$ Solved by Layer 7 (50KB/2k-line disk spooler + balanced head/tail extraction).
+2. **Mid-stream token truncation** $\rightarrow$ Solved by Layer 4 (Strict `stop_reason == "length"` rejection guard).
+3. **File write race conditions** $\rightarrow$ Solved by Layer 6 (`FileMutationQueue` canonical realpath serialization).
+4. **KV cache invalidation cascades** $\rightarrow$ Solved by Layer 2 (Immutable Baseline Epochs freezing Tiers 1–4).
+5. **Blind file traversal loops** $\rightarrow$ Solved by Layer 3 (v1: Fast substring ripgrep & globbing / v2: Tree-sitter AST fallback).
+6. **Unsandboxed host execution** $\rightarrow$ Solved by Layer 0 (Multi-platform kernel isolation: `bwrap`, `Seatbelt`, E2B MicroVMs).
+
+---
+
+## 🚀 Installation & Quick Start
+
+Official Website & Documentation: **[https://pari-cli.in](https://pari-cli.in)**
+
+Choose your platform's installation command:
+
+### 1. macOS & Linux (`curl`)
+```bash
+curl -fsSL https://pari-cli.in/install.sh | bash
+```
+
+### 2. Windows (`irm` in PowerShell)
+```powershell
+irm https://www.pari-cli.in/install.ps1 | iex
+```
+
+### 3. Via `pip` / `pipx` / `uv`
+```bash
+# Recommended (isolated CLI)
+pipx install pari-cli
+
+# Fast via uv
+uv tool install pari-cli
+
+# Standard pip
+pip install pari-cli
+```
+
+---
+
+### 💻 Launch Interactive Session
+```bash
+# Export your API key
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# Launch PARI anywhere in your project workspace
+pari-cli
+```
+
+---
+
+## ⚖️ License
+
+MIT License. See [LICENSE](LICENSE) for details.

pari_cli-0.1.4/README.md

@@ -0,0 +1,68 @@
+# PARI — Next-Generation Terminal Coding Agent
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![Architecture: 11-Layer Stack](https://img.shields.io/badge/architecture-11--layer-green.svg)](docs/architecture/overview.md)
+[![Security: Kernel Sandboxed](https://img.shields.io/badge/sandbox-bwrap%20%7C%20Seatbelt%20%7C%20E2B-orange.svg)](docs/layers/layer-0-sandboxing.md)
+
+---
+
+## ⚡ The Core Thesis
+
+$$\text{\bf Agent failure is a systems engineering failure, not a reasoning failure.}$$
+
+The exact same frontier reasoning model (Claude 3.7 Sonnet, GPT-4o) demonstrates a **15% pass rate** in a naive loop, but achieves a **50–55% pass rate** inside an engineered harness. The 35% delta is not model intelligence; it is accounted for by **six fatal systems failure modes**:
+
+1. **Unbounded stdout poisoning** $\rightarrow$ Solved by Layer 7 (50KB/2k-line disk spooler + balanced head/tail extraction).
+2. **Mid-stream token truncation** $\rightarrow$ Solved by Layer 4 (Strict `stop_reason == "length"` rejection guard).
+3. **File write race conditions** $\rightarrow$ Solved by Layer 6 (`FileMutationQueue` canonical realpath serialization).
+4. **KV cache invalidation cascades** $\rightarrow$ Solved by Layer 2 (Immutable Baseline Epochs freezing Tiers 1–4).
+5. **Blind file traversal loops** $\rightarrow$ Solved by Layer 3 (v1: Fast substring ripgrep & globbing / v2: Tree-sitter AST fallback).
+6. **Unsandboxed host execution** $\rightarrow$ Solved by Layer 0 (Multi-platform kernel isolation: `bwrap`, `Seatbelt`, E2B MicroVMs).
+
+---
+
+## 🚀 Installation & Quick Start
+
+Official Website & Documentation: **[https://pari-cli.in](https://pari-cli.in)**
+
+Choose your platform's installation command:
+
+### 1. macOS & Linux (`curl`)
+```bash
+curl -fsSL https://pari-cli.in/install.sh | bash
+```
+
+### 2. Windows (`irm` in PowerShell)
+```powershell
+irm https://www.pari-cli.in/install.ps1 | iex
+```
+
+### 3. Via `pip` / `pipx` / `uv`
+```bash
+# Recommended (isolated CLI)
+pipx install pari-cli
+
+# Fast via uv
+uv tool install pari-cli
+
+# Standard pip
+pip install pari-cli
+```
+
+---
+
+### 💻 Launch Interactive Session
+```bash
+# Export your API key
+export ANTHROPIC_API_KEY="sk-ant-..."
+
+# Launch PARI anywhere in your project workspace
+pari-cli
+```
+
+---
+
+## ⚖️ License
+
+MIT License. See [LICENSE](LICENSE) for details.

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

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

{pari_cli-0.1.3 → pari_cli-0.1.4}/pari/agent/guards.py

@@ -5,7 +5,9 @@ The loop itself decides when to stop. These values are the limits it checks.
 
 MAX_TURNS = 40
 TURN_WARNING = 30
+TURN_EXTENSION = 10
 DAEMON_IDLE_SECONDS = 10
+TURN_LIMIT_PROMPT = "[Turn limit reached. Continue (+10 turns) | Revert | Stop]?"
 
 # Shown when stop_reason is "length". The loop must drop the pending tool
 # calls before it appends this notice. A truncated edit must not touch disk.

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

@@ -17,6 +17,7 @@ from pari.agent.guards import (
     DAEMON_IDLE_SECONDS,
     LENGTH_TRUNCATION_NOTICE,
     MAX_TURNS,
+    TURN_LIMIT_PROMPT,
     TURN_WARNING,
     format_daemon_notice,
     is_length_stop,
@@ -49,7 +50,6 @@ class TurnResult:
     cached_tokens: int = 0
 
 
-_TURN_LIMIT = "[Turn limit reached. Continue (+10 turns) | Revert | Stop]?"
 _FILE_TOOLS = frozenset({"write_file", "edit_file"})
 
 
@@ -66,6 +66,7 @@ class AgentExecutionLoop:
         undo: GuardedUndoManager | None = None,
         workspace: Path | None = None,
         on_tool_call: Callable[[str, dict[str, Any]], None] | None = None,
+        on_tool_result: Callable[[ToolCall, str], None] | None = None,
         on_diff: Callable[[str, str], None] | None = None,
         on_warning: Callable[[str], None] | None = None,
     ):
@@ -76,6 +77,7 @@ class AgentExecutionLoop:
         self.undo = undo
         self.workspace = workspace
         self.on_tool_call = on_tool_call
+        self.on_tool_result = on_tool_result
         self.on_diff = on_diff
         self.on_warning = on_warning
         self._warning = ""
@@ -140,19 +142,21 @@ class AgentExecutionLoop:
                 return finish(halt, executed, True)
             history = _append(history, response_text)
             pending = feedback
-        return finish(_TURN_LIMIT, executed, True, capture_diff=True)
+        return finish(TURN_LIMIT_PROMPT, executed, True, capture_diff=True)
 
     async def _run_calls(
         self, calls: list[ToolCall], executed: int
     ) -> tuple[str, int, str | None]:
         """Run the calls in order. A failure stops the rest of this batch."""
         notes: list[str] = []
-        for call in calls:
+        for index, call in enumerate(calls):
             path = _file_path(call)
             before = self._read_rel(path) if path is not None else ""
             try:
                 text = await self._execute_call(call)
             except Exception as exc:
+                self._report_result(call, f"{type(exc).__name__}: {exc}")
+                self._skip_rest(calls[index + 1 :])
                 return self._fail(type(exc).__name__, str(exc), executed)
             executed += 1
             if path is not None:
@@ -160,7 +164,10 @@ class AgentExecutionLoop:
                 self._snapshot(path, before, after)
                 lint = lint_python(path, after)
                 if lint is not None:
+                    self._report_result(call, lint)
+                    self._skip_rest(calls[index + 1 :])
                     return self._fail("LINT ERROR", lint, executed)
+            self._report_result(call, text)
             notes.append(text)
         return "\n".join(notes), executed, None
 
@@ -179,6 +186,14 @@ class AgentExecutionLoop:
             self.logger.append_event("TOOL_RESULT", {"tool": call.name, "output": text})
         return text
 
+    def _report_result(self, call: ToolCall, text: str) -> None:
+        if self.on_tool_result is not None:
+            self.on_tool_result(call, text)
+
+    def _skip_rest(self, calls: list[ToolCall]) -> None:
+        for call in calls:
+            self._report_result(call, "Skipped because an earlier call failed.")
+
     def _log_assistant(self, text: str) -> None:
         if self.logger is None:
             return

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

@@ -14,12 +14,17 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
-from pari.agent.guards import is_length_stop
-from pari.agent.loop import AgentExecutionLoop
+from pari.agent.guards import (
+    MAX_TURNS,
+    TURN_EXTENSION,
+    TURN_LIMIT_PROMPT,
+    is_length_stop,
+)
+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
+from pari.providers.base import LLMProvider, ModelResponse, ProviderMessage, ToolCall
 from pari.routing.router import DualModelRouter, router_for
 from pari.session.events import SessionEventType
 from pari.session.logger import SessionLogger
@@ -39,6 +44,7 @@ class AgentRuntime:
         edit_fallback: str = "none",
         repomap: str = "off",
         router: DualModelRouter | None = None,
+        sandbox_mode: str | None = None,
     ):
         self.workspace = workspace.resolve()
         self.session_file = session_file or (self.workspace / ".pari" / "session.jsonl")
@@ -51,7 +57,14 @@ class AgentRuntime:
         self._owns_router = router is None
         self.router = router if router is not None else router_for(self.provider)
         self.undo_manager = GuardedUndoManager(self.workspace)
-        self.tools = get_default_registry(self.workspace, edit_fallback=edit_fallback)
+        self.tools = get_default_registry(
+            self.workspace,
+            edit_fallback=edit_fallback,
+            sandbox_mode=sandbox_mode,
+        )
+        self.awaiting_limit = False
+        self.last_result: TurnResult | None = None
+        self._tool_followup = False
         self.pinned_files: list[str] = []
         self.session_id: str | None = None
         self.messages: list[ProviderMessage] = []
@@ -110,23 +123,33 @@ class AgentRuntime:
     def add_pinned_file(self, rel_path: str) -> bool:
         """Pin reference file into active context."""
         file_path = (self.workspace / rel_path).resolve()
-        if not file_path.exists():
+        if not file_path.is_file():
+            return False
+        try:
+            clean_rel = str(file_path.relative_to(self.workspace))
+        except ValueError:
             return False
-        clean_rel = str(file_path.relative_to(self.workspace))
         if clean_rel not in self.pinned_files:
             self.pinned_files.append(clean_rel)
         return True
 
+    async def continue_turn(self) -> str:
+        """Run another block of turns after the user chooses Continue."""
+        return await self.execute_turn("Continue.", 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,
+        *,
+        max_turns: int | None = None,
     ) -> str:
         """Execute conversational turn with autonomous tool execution."""
         self.on_tool_call = on_tool_call
         self.on_diff = on_diff
         self.turn_warning = ""
+        self._tool_followup = False
         if not self.session_id:
             self.start_session()
         self.router.begin_turn()
@@ -134,7 +157,11 @@ class AgentRuntime:
         schemas = self.tools.get_schemas()
 
         async def step(context: str, _turn: int) -> ModelResponse:
-            self.messages.append(ProviderMessage(role="user", content=context))
+            # After a tool call, the results are already on the transcript.
+            # A new user message here would hide them from the model.
+            if not self._tool_followup:
+                self.messages.append(ProviderMessage(role="user", content=context))
+            self._tool_followup = False
             # Wide prompts plan once, with no tools. The editor runs the calls.
             resp = await self.router.complete(
                 self.messages,
@@ -143,7 +170,11 @@ class AgentRuntime:
                 active_files=self.pinned_files,
             )
             # Drop tool calls that were cut off so the next step cannot rerun them.
-            calls = [] if is_length_stop(resp.stop_reason) else resp.tool_calls
+            calls = [] if is_length_stop(resp.stop_reason) else list(resp.tool_calls)
+            for index, call in enumerate(calls):
+                if not call.id:
+                    call.id = f"call_{index}"
+            self._tool_followup = bool(calls)
             self.messages.append(
                 ProviderMessage(
                     role="assistant",
@@ -153,18 +184,25 @@ class AgentRuntime:
             )
             return resp
 
+        def remember_result(call: ToolCall, text: str) -> None:
+            self.messages.append(
+                ProviderMessage(role="tool", content=text, tool_call_id=call.id)
+            )
+
         dag = self.workspace / ".pari" / "sessions" / f"{self.session_id}.jsonl"
 
         def remember_warning(text: str) -> None:
             self.turn_warning = text
 
         loop = AgentExecutionLoop(
+            max_turns if max_turns is not None else MAX_TURNS,
             registry=self.tools,
             reflection=ReflectionManager(),
             logger=SessionLogger(dag),
             undo=self.undo_manager,
             workspace=self.workspace,
             on_tool_call=on_tool_call,
+            on_tool_result=remember_result,
             on_diff=on_diff,
             on_warning=remember_warning,
         )
@@ -189,6 +227,8 @@ class AgentRuntime:
         self.tokens_in = result.tokens_in
         self.tokens_out = result.tokens_out
         self.cached_tokens = result.cached_tokens
+        self.last_result = result
+        self.awaiting_limit = result.response_text == TURN_LIMIT_PROMPT
         return result.response_text
 
     def _repo_map(self) -> str:

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

@@ -1,8 +1,9 @@
-"""Account sign-in for the five providers.
+"""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 browser login, so the account token is pasted. Radius is not a provider.
+no account login, so that path does not ask for a token. Radius is not a
+provider.
 """
 
 import base64
@@ -89,10 +90,10 @@ 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":
-        token = ui.read_line("Paste your DeepSeek account token:")
-        if not token or not token.strip():
-            raise LoginCancelled()
-        return sign_in(info.id, token, "account", store)
+        raise ValueError(
+            "DeepSeek has no account sign-in. "
+            "Use pari-cli login deepseek --api-key <key>."
+        )
     if info.id == "openai":
         cred = _login_openai(ui, store)
     elif info.id == "anthropic":

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

@@ -1,15 +1,26 @@
 """``pari-cli login`` screens: method, provider, then the sign-in itself."""
 
 import base64
+import ctypes
 import getpass
 import os
 import select
 import sys
-import termios
 import time
-import tty
 import webbrowser
 
+
+try:
+    import msvcrt
+except ImportError:
+    msvcrt = None
+try:
+    import termios
+    import tty
+except ImportError:
+    termios = None
+    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.menu import (
@@ -128,6 +139,12 @@ def _finish(kind: str, provider_id: str, ui: AccountUI, store: AuthStore) -> str
     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 None
         return sign_in_account(info.id, ui, store)
     except LoginCancelled:
         return None
@@ -279,6 +296,10 @@ class TerminalLogin:
         if self._raw:
             return
         self._fd = sys.stdin.fileno()
+        if termios is None or tty is None:
+            _enable_windows_vt()
+            self._raw = True
+            return
         current = termios.tcgetattr(self._fd)
         self._term = _copy_mode(current)
         # cbreak, not raw: raw turns off newline output, so each row is drawn
@@ -393,7 +414,17 @@ def read_menu_key(fd: int, pending: bytes, timeout: float | None) -> tuple[str,
             return key, pending
 
 
+_WIN_ARROWS = {
+    "H": b"\x1b[A",
+    "P": b"\x1b[B",
+    "K": b"\x1b[D",
+    "M": b"\x1b[C",
+}
+
+
 def _read_chunk(fd: int, timeout: float | None) -> bytes:
+    if msvcrt is not None:
+        return _read_windows(timeout)
     if timeout is not None:
         ready, _, _ = select.select([fd], [], [], timeout)
         if not ready:
@@ -404,6 +435,35 @@ def _read_chunk(fd: int, timeout: float | None) -> bytes:
         return b""
 
 
+def _read_windows(timeout: float | None) -> bytes:
+    if timeout is not None and not _windows_ready(timeout):
+        return b""
+    char = msvcrt.getwch()
+    if char in ("\x00", "\xe0"):
+        return _WIN_ARROWS.get(msvcrt.getwch(), b"")
+    return char.encode("utf-8")
+
+
+def _windows_ready(timeout: float) -> bool:
+    deadline = time.monotonic() + timeout
+    while not msvcrt.kbhit():
+        if time.monotonic() >= deadline:
+            return False
+        time.sleep(0.01)
+    return True
+
+
+def _enable_windows_vt() -> None:
+    if msvcrt is None:
+        return
+    kernel = ctypes.windll.kernel32
+    handle = kernel.GetStdHandle(-11)
+    mode = ctypes.c_uint()
+    if not kernel.GetConsoleMode(handle, ctypes.byref(mode)):
+        return
+    kernel.SetConsoleMode(handle, mode.value | 0x0004)
+
+
 def _split_sequence(buf: bytes) -> tuple[bytes | None, bytes]:
     """Split one key from ``buf``. None means an unfinished Escape sequence."""
     if not buf:

{pari_cli-0.1.3 → pari_cli-0.1.4}/pari/auth/login.py

@@ -35,6 +35,11 @@ def sign_in(
     if method not in ("api_key", "account"):
         raise ValueError("Sign in with an API key or an account token.")
     info = get_info(provider_id)
+    if method == "account" and info.id == "deepseek":
+        raise ValueError(
+            "DeepSeek has no account sign-in. "
+            "Use pari-cli login deepseek --api-key <key>."
+        )
     token = secret.strip()
     if not token:
         raise ValueError("The credential is empty.")
@@ -50,6 +55,8 @@ def sign_in(
     expires = (extra or {}).get("expires")
     if isinstance(expires, int):
         row["expires"] = expires
+    # Latest sign-in is the session default, so it has to be last.
+    data.pop(info.id, None)
     data[info.id] = row
     auth.save(data)
     label = "API key" if method == "api_key" else "account"
@@ -142,7 +149,49 @@ def _now_ms() -> int:
     return int(time.time() * 1000)
 
 
+NO_MODEL = (
+    "No model selected. Sign in with `pari-cli login`, "
+    "or pass --model, or set PARI_MODEL."
+)
+
+
+def default_model_name(store: AuthStore | None = None) -> str | None:
+    """Model used when the CLI was started without ``--model``.
+
+    ``PARI_MODEL`` wins. Otherwise the latest saved sign-in is used, then an
+    API key already in the environment. Nothing is chosen when no credential
+    is available.
+    """
+    chosen = os.environ.get("PARI_MODEL", "").strip()
+    if chosen:
+        return chosen
+    saved = _saved_provider_ids((store or AuthStore()).load())
+    if saved:
+        return get_info(saved[-1]).default_model
+    for info in PROVIDERS:
+        if os.environ.get(info.env, "").strip():
+            return info.default_model
+    return None
+
+
+def _saved_provider_ids(data: dict) -> list[str]:
+    ids: list[str] = []
+    for key, row in data.items():
+        if not isinstance(key, str) or not isinstance(row, dict):
+            continue
+        secret = row.get("secret")
+        if not isinstance(secret, str) or not secret.strip():
+            continue
+        try:
+            ids.append(get_info(key).id)
+        except ValueError:
+            continue
+    return ids
+
+
 def sign_in_hint(info: ProviderInfo) -> str:
+    if info.id == "deepseek":
+        return "Sign in to DeepSeek: pari-cli login deepseek --api-key <key>."
     return (
         f"Sign in to {info.label}: "
         f"pari-cli login {info.id} --api-key <key> "

{pari_cli-0.1.3 → pari_cli-0.1.4}/pari/auth/menu.py

@@ -30,6 +30,8 @@ def provider_rows(method: str, store: AuthStore | None = None) -> list[ProviderC
     """Providers in name order, each with a status that does not include the secret."""
     data = (store or AuthStore()).load()
     infos = sorted(PROVIDERS, key=lambda item: item.label.lower())
+    if method == "account":
+        infos = [info for info in infos if info.id != "deepseek"]
     return [
         ProviderChoice(info.id, info.label, _status(info, method, data))
         for info in infos