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

{pari_cli-0.1.2/pari_cli.egg-info → pari_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pari-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: A resilient, sandbox-first terminal coding agent engineered for high pass rates and low token burn.
 Author: PARI Contributors
 License: MIT
@@ -27,6 +27,9 @@ 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"
@@ -35,7 +38,7 @@ 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[ast,cloud,dev]; extra == "all"
+Requires-Dist: pari-cli[ast,cloud,dev]; extra == "all"
 Dynamic: license-file
 
 # PARI — Next-Generation Terminal Coding Agent
@@ -162,7 +165,7 @@ pip install pari-cli
 export ANTHROPIC_API_KEY="sk-ant-..."
 
 # Launch PARI anywhere in your project workspace
-pari
+pari-cli
 ```
 
 ---

{pari_cli-0.1.2 → pari_cli-0.1.3}/README.md

@@ -122,7 +122,7 @@ pip install pari-cli
 export ANTHROPIC_API_KEY="sk-ant-..."
 
 # Launch PARI anywhere in your project workspace
-pari
+pari-cli
 ```
 
 ---

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

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

{pari_cli-0.1.2 → pari_cli-0.1.3}/pari/__main__.py

@@ -6,7 +6,9 @@ Allows running PARI via:
 """
 
 import sys
+
 from pari.cli import main
 
+
 if __name__ == "__main__":
     sys.exit(main())

pari_cli-0.1.3/pari/agent/__init__.py

@@ -0,0 +1,43 @@
+"""PARI Layer 4: The Execution Loop (Agent Runtime).
+
+Architectural Purpose:
+    Implements the double-while execution loop with stop_reason == "length" truncation
+    guard,
+    bounded reflection retry limits, and lightweight asyncio fiber-based subagents.
+
+Subsystems:
+    - loop: Core double-while agent loop with continuation handling
+    - runtime: Turn execution, tool orchestration, and state transitions
+    - reflection: Structured error injection with max 3 reflection retries
+    - subagent: Fiber-based read-only research subagents (closing Pi F2 RAM bloat)
+"""
+
+from pari.agent.guards import (
+    DAEMON_IDLE_SECONDS,
+    LENGTH_TRUNCATION_NOTICE,
+    MAX_TURNS,
+    TURN_WARNING,
+    format_daemon_notice,
+    is_length_stop,
+)
+from pari.agent.loop import AgentExecutionLoop, TurnResult
+from pari.agent.reflection import ReflectionManager, format_lint_error
+from pari.agent.runtime import AgentRuntime
+from pari.agent.subagent import FiberSubagentPool, SubagentTask
+
+
+__all__ = [
+    "DAEMON_IDLE_SECONDS",
+    "LENGTH_TRUNCATION_NOTICE",
+    "MAX_TURNS",
+    "TURN_WARNING",
+    "AgentExecutionLoop",
+    "AgentRuntime",
+    "FiberSubagentPool",
+    "ReflectionManager",
+    "SubagentTask",
+    "TurnResult",
+    "format_daemon_notice",
+    "format_lint_error",
+    "is_length_stop",
+]

pari_cli-0.1.3/pari/agent/guards.py

@@ -0,0 +1,33 @@
+"""Constants and checks the execution loop applies before it runs a tool.
+
+The loop itself decides when to stop. These values are the limits it checks.
+"""
+
+MAX_TURNS = 40
+TURN_WARNING = 30
+DAEMON_IDLE_SECONDS = 10
+
+# 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.
+LENGTH_TRUNCATION_NOTICE = (
+    "WARNING: Your previous tool call was truncated due to the "
+    "output token ceiling. No changes were written to disk. "
+    "Please break your modification into smaller, focused "
+    "search/replace blocks of <= 100 lines."
+)
+
+
+def is_length_stop(stop_reason: str | None) -> bool:
+    """True when the model hit max_tokens and the tool payload may be cut off."""
+    return stop_reason == "length"
+
+
+def format_daemon_notice(command: str, idle_seconds: int = DAEMON_IDLE_SECONDS) -> str:
+    """Notice for a command that kept streaming past the idle window."""
+    shown = command.strip() or "command"
+    return (
+        f"[DAEMON DETECTED]: Command '{shown}' did not exit after "
+        f"{idle_seconds}s. Process was backgrounded. "
+        "Stdout snapshot spooled to disk. "
+        "To manage background daemons, use background task APIs."
+    )

pari_cli-0.1.3/pari/agent/lint.py

@@ -0,0 +1,49 @@
+"""Syntax check for a file the loop just wrote.
+
+The check uses the standard library parser. It returns a short window around
+the failing line so the next model turn does not receive a compiler log.
+"""
+
+import ast
+
+from pari.agent.reflection import format_lint_error
+
+
+def lint_python(path: str, source: str) -> str | None:
+    """Return a lint block when path is Python and source does not parse."""
+    if not path.endswith(".py"):
+        return None
+    try:
+        ast.parse(source)
+    except SyntaxError as exc:
+        line = exc.lineno or 1
+        return format_lint_error(
+            path,
+            line,
+            _enclosing(source, line),
+            _window(source, line, exc.msg),
+        )
+    return None
+
+
+def _enclosing(source: str, line: int) -> str:
+    rows = source.splitlines()
+    last = min(line, len(rows)) - 1
+    for index in range(last, -1, -1):
+        stripped = rows[index].lstrip()
+        if stripped.startswith(("def ", "async def ", "class ")):
+            return stripped
+    return "<module>"
+
+
+def _window(source: str, line: int, message: str) -> str:
+    rows = source.splitlines()
+    start = max(line - 5, 1)
+    end = min(line + 5, len(rows))
+    shown: list[str] = []
+    for number in range(start, end + 1):
+        text = rows[number - 1] if number <= len(rows) else ""
+        if number == line:
+            text = f"{text}  # {message}"
+        shown.append(f"{number}: {text}")
+    return "\n".join(shown)

pari_cli-0.1.3/pari/agent/loop.py

@@ -0,0 +1,374 @@
+"""PARI Layer 4: Double-While Execution Loop.
+
+Outer loop: one model call per autonomous turn, up to the turn ceiling.
+Inner step: one provider completion. A length stop drops that completion's
+tool calls. Tool results, lint failures, and daemon notices become the next
+prompt. The turn ends when the model stops asking for tools.
+"""
+
+import json
+import subprocess
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Protocol
+
+from pari.agent.guards import (
+    DAEMON_IDLE_SECONDS,
+    LENGTH_TRUNCATION_NOTICE,
+    MAX_TURNS,
+    TURN_WARNING,
+    format_daemon_notice,
+    is_length_stop,
+)
+from pari.agent.lint import lint_python
+from pari.agent.reflection import ReflectionManager
+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.session.logger import SessionLogger
+from pari.session.undo import GuardedUndoManager
+
+
+class ToolExecutor(Protocol):
+    async def execute(self, name: str, arguments: dict[str, Any]) -> Any: ...
+
+
+@dataclass
+class TurnResult:
+    response_text: str
+    tool_calls_executed: int
+    tokens_used: int
+    requires_user_input: bool
+    warning: str = ""
+    diff: str = ""
+    tokens_in: int = 0
+    tokens_out: int = 0
+    cached_tokens: int = 0
+
+
+_TURN_LIMIT = "[Turn limit reached. Continue (+10 turns) | Revert | Stop]?"
+_FILE_TOOLS = frozenset({"write_file", "edit_file"})
+
+
+class AgentExecutionLoop:
+    """Runs autonomous tool turns until the model stops or a guard fires."""
+
+    def __init__(
+        self,
+        max_autonomous_turns: int = MAX_TURNS,
+        *,
+        registry: ToolExecutor | None = None,
+        reflection: ReflectionManager | None = None,
+        logger: SessionLogger | None = None,
+        undo: GuardedUndoManager | None = None,
+        workspace: Path | None = None,
+        on_tool_call: Callable[[str, dict[str, Any]], None] | None = None,
+        on_diff: Callable[[str, str], None] | None = None,
+        on_warning: Callable[[str], None] | None = None,
+    ):
+        self.max_autonomous_turns = max_autonomous_turns
+        self.registry = registry
+        self.reflection = reflection or ReflectionManager()
+        self.logger = logger
+        self.undo = undo
+        self.workspace = workspace
+        self.on_tool_call = on_tool_call
+        self.on_diff = on_diff
+        self.on_warning = on_warning
+        self._warning = ""
+
+    async def run_turn(
+        self,
+        prompt: str,
+        step_fn: Callable[[str, int], Any],
+        is_length_truncated: Callable[[Any], bool],
+        active_files: list[tuple[str, str]] | None = None,
+        repo_map: str = "",
+    ) -> TurnResult:
+        """Execute autonomous steps for one user prompt.
+
+        step_fn(context, turn) returns a ModelResponse or a plain string.
+        A length stop is not executed: the tool payload may be cut off.
+        """
+        self.reflection.reset("turn")
+        if self.logger is not None:
+            self.logger.append_event("USER_TURN", {"prompt": prompt})
+        pending = prompt
+        history = ""
+        executed = 0
+        tokens_in = 0
+        tokens_out = 0
+        cached_tokens = 0
+        response_text = ""
+
+        def finish(
+            text: str, count: int, needs_user: bool, *, capture_diff: bool = False
+        ) -> TurnResult:
+            return self._finish(
+                text,
+                count,
+                tokens_in + tokens_out,
+                needs_user,
+                capture_diff=capture_diff,
+                tokens_in=tokens_in,
+                tokens_out=tokens_out,
+                cached_tokens=cached_tokens,
+            )
+
+        for turn in range(1, self.max_autonomous_turns + 1):
+            self._note_turn(turn)
+            context = _render_context(pending, history, active_files or [], repo_map)
+            step = await _resolve(step_fn(context, turn))
+            step_in, step_out, step_cached = _usage(step)
+            tokens_in += step_in
+            tokens_out += step_out
+            cached_tokens += step_cached
+            response_text = _text(step)
+            # A truncated tool call is discarded. The file is left untouched.
+            if _truncated(step, is_length_truncated):
+                history = _append(history, response_text)
+                pending = LENGTH_TRUNCATION_NOTICE
+                continue
+            calls = _calls(step)
+            if not calls:
+                return finish(response_text, executed, False)
+            feedback, executed, halt = await self._run_calls(calls, executed)
+            if halt is not None:
+                return finish(halt, executed, True)
+            history = _append(history, response_text)
+            pending = feedback
+        return finish(_TURN_LIMIT, 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:
+            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:
+                return self._fail(type(exc).__name__, str(exc), executed)
+            executed += 1
+            if path is not None:
+                after = self._read_rel(path)
+                self._snapshot(path, before, after)
+                lint = lint_python(path, after)
+                if lint is not None:
+                    return self._fail("LINT ERROR", lint, executed)
+            notes.append(text)
+        return "\n".join(notes), executed, None
+
+    async def _execute_call(self, call: ToolCall) -> str:
+        if self.registry is None:
+            raise RuntimeError(f"No tool registry configured for {call.name}")
+        if self.on_tool_call is not None:
+            self.on_tool_call(call.name, call.arguments)
+        if self.logger is not None:
+            self.logger.append_event(
+                "TOOL_CALL", {"tool": call.name, "arguments": call.arguments}
+            )
+        result = await self.registry.execute(call.name, call.arguments)
+        text = _render_result(call, result)
+        if self.logger is not None:
+            self.logger.append_event("TOOL_RESULT", {"tool": call.name, "output": text})
+        return text
+
+    def _log_assistant(self, text: str) -> None:
+        if self.logger is None:
+            return
+        self.logger.append_event("ASSISTANT_TURN", {"text": text})
+
+    def _note_turn(self, turn: int) -> None:
+        """Warn the user at turn 30. The warning stays out of the model prompt."""
+        if turn != TURN_WARNING:
+            return
+        self._warning = f"Turn {turn} of {self.max_autonomous_turns}."
+        if self.on_warning is not None:
+            self.on_warning(self._warning)
+
+    def _fail(
+        self, kind: str, message: str, executed: int
+    ) -> tuple[str, int, str | None]:
+        note = self.reflection.record_failure("turn", kind, message)
+        if kind == "LINT ERROR":
+            shown = message
+        else:
+            shown = note
+        if self.reflection.should_retry("turn"):
+            return shown, executed, None
+        if kind == "LINT ERROR":
+            shown = f"{message}\nReflection limit reached. Stop and ask the user."
+        return shown, executed, shown
+
+    def _finish(
+        self,
+        text: str,
+        executed: int,
+        tokens: int,
+        needs_user: bool,
+        *,
+        capture_diff: bool = False,
+        tokens_in: int = 0,
+        tokens_out: int = 0,
+        cached_tokens: int = 0,
+    ) -> TurnResult:
+        diff = ""
+        if capture_diff:
+            diff = workspace_diff(self.workspace)
+            if diff and self.on_diff is not None:
+                self.on_diff(".", diff)
+        self._log_assistant(text)
+        return TurnResult(
+            text,
+            executed,
+            tokens,
+            needs_user,
+            self._warning,
+            diff,
+            tokens_in,
+            tokens_out,
+            cached_tokens,
+        )
+
+    def _read_rel(self, rel: str) -> str:
+        if self.workspace is None:
+            return ""
+        try:
+            path = resolve_safe_path(self.workspace, rel)
+        except PermissionError:
+            return ""
+        if not path.is_file():
+            return ""
+        try:
+            return path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            return ""
+
+    def _snapshot(self, rel: str, before: str, after: str) -> None:
+        if before == after:
+            return
+        if self.undo is not None:
+            self.undo.record_snapshot(rel, before, after)
+        if self.logger is not None:
+            self.logger.append_event("FILE_SNAPSHOT", {"path": rel})
+        if self.on_diff is not None:
+            self.on_diff(rel, generate_unified_diff(before, after, rel))
+
+
+def _render_context(
+    prompt: str,
+    history: str,
+    active_files: list[tuple[str, str]],
+    repo_map: str = "",
+) -> str:
+    chunks: list[ContextChunk] = []
+    if repo_map:
+        chunks.append(ContextChunk(ContextTier.STATIC_REPO_MAP, repo_map, "repomap"))
+    if active_files:
+        body = "\n".join(f"# {name}\n{content}" for name, content in active_files)
+        chunks.append(ContextChunk(ContextTier.ACTIVE_FILES, body, "files"))
+    if history:
+        chunks.append(ContextChunk(ContextTier.TURN_HISTORY, history, "history"))
+    chunks.append(ContextChunk(ContextTier.CURRENT_TURN, prompt, "turn"))
+    packed = assemble_context(compact_context(chunks))
+    return "\n".join(str(item["content"]) for item in packed)
+
+
+def _append(history: str, text: str) -> str:
+    if not history:
+        return text
+    return f"{history}\n{text}"
+
+
+async def _resolve(step: Any) -> Any:
+    if isinstance(step, Awaitable):
+        return await step
+    return step
+
+
+def _truncated(step: Any, is_length_truncated: Callable[[Any], bool]) -> bool:
+    if is_length_truncated(step):
+        return True
+    if isinstance(step, ModelResponse):
+        return is_length_stop(step.stop_reason)
+    return False
+
+
+def _calls(step: Any) -> list[ToolCall]:
+    if isinstance(step, ModelResponse):
+        return list(step.tool_calls)
+    return []
+
+
+def _text(step: Any) -> str:
+    if isinstance(step, ModelResponse):
+        return step.text
+    if isinstance(step, str):
+        return step
+    raise TypeError("step_fn must return a string or ModelResponse")
+
+
+def _usage(step: Any) -> tuple[int, int, int]:
+    if isinstance(step, ModelResponse):
+        return step.tokens_in, step.tokens_out, step.cached_tokens
+    return 0, 0, 0
+
+
+def _render_result(call: ToolCall, result: Any) -> str:
+    timed_out = False
+    if isinstance(result, str):
+        text = result
+    elif isinstance(result, dict):
+        timed_out = bool(result.get("timed_out"))
+        text = json.dumps(result)
+    else:
+        text = str(result)
+    if not timed_out:
+        return text
+    command = str(call.arguments.get("command", call.name))
+    seconds = _idle_seconds(result)
+    return format_daemon_notice(command, seconds) + "\n" + text
+
+
+def _file_path(call: ToolCall) -> str | None:
+    if call.name not in _FILE_TOOLS:
+        return None
+    path = call.arguments.get("path")
+    if not isinstance(path, str) or not path:
+        return None
+    return path
+
+
+def _idle_seconds(result: Any) -> int:
+    """Prefer the daemon window over the tool's longer hard timeout."""
+    if not isinstance(result, dict):
+        return DAEMON_IDLE_SECONDS
+    for key in ("idle_seconds", "timeout"):
+        raw = result.get(key)
+        if isinstance(raw, int | float):
+            return int(raw)
+    return DAEMON_IDLE_SECONDS
+
+
+def workspace_diff(workspace: Path | None) -> str:
+    """Return the working-tree diff, or an empty string when git cannot run."""
+    if workspace is None:
+        return ""
+    try:
+        completed = subprocess.run(
+            ["git", "diff", "--no-ext-diff", "--"],
+            cwd=workspace,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return ""
+    return completed.stdout

pari_cli-0.1.3/pari/agent/reflection.py

@@ -0,0 +1,75 @@
+"""PARI Layer 4: Reflection & Error Injection Manager.
+
+Architectural Purpose:
+    Closes Aider F5 (Reflection loop token burn: $0.50-$2.00 per stubborn diff).
+    When a tool call or edit fails:
+    1. Formats the error into a high-signal structured diagnostic.
+    2. Limits reflection attempts to max_reflections (default: 3).
+    3. If 3 attempts fail, halts execution and prompts the user for intervention,
+       preventing infinite token-burning retry loops.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ReflectionAttempt:
+    error_type: str
+    error_message: str
+    attempt_count: int
+
+
+class ReflectionManager:
+    """Guards reflection retries to prevent unbounded token expenditure."""
+
+    def __init__(self, max_reflections: int = 3):
+        self.max_reflections = max_reflections
+        self._counts: dict[str, int] = {}
+
+    def should_retry(self, operation_id: str) -> bool:
+        """True while this operation still has attempts left.
+
+        The count goes up in record_failure. After max_reflections failures
+        the loop must stop and ask the user instead of calling the model again.
+        """
+        return self._counts.get(operation_id, 0) < self.max_reflections
+
+    def record_failure(self, operation_id: str, error_type: str, message: str) -> str:
+        """Count the failure and return the prompt block for the next turn."""
+        count = self._counts.get(operation_id, 0) + 1
+        self._counts[operation_id] = count
+        attempt = ReflectionAttempt(error_type, message, count)
+        if count >= self.max_reflections:
+            ending = " Reflection limit reached. Stop and ask the user."
+        else:
+            ending = " Retry with a smaller, targeted change."
+        return (
+            f"[{attempt.error_type}] attempt {attempt.attempt_count}"
+            f"/{self.max_reflections}: {attempt.error_message}.{ending}"
+        )
+
+    def reset(self, operation_id: str | None = None) -> None:
+        """Clear failure counts for one operation, or for every operation."""
+        if operation_id is None:
+            self._counts.clear()
+            return
+        self._counts.pop(operation_id, None)
+
+
+def format_lint_error(
+    path: str,
+    line_number: int,
+    enclosing: str,
+    window: str,
+) -> str:
+    """Build the short lint block the loop injects after a failed edit.
+
+    The window should already be the few lines around the error. This function
+    does not read the file, so it cannot pull a whole compiler log back in.
+    """
+    return (
+        f"[LINT ERROR] In {path}:{line_number}:\n"
+        f"Enclosing function: {enclosing}\n"
+        f"{window}\n"
+        "Fix the specific error above using a targeted search/replace edit."
+    )