pi-agent-cli-lc 0.2.0__tar.gz → 0.3.0__tar.gz

pi_agent_cli_lc-0.3.0/.gitignore

@@ -0,0 +1,33 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+.pytest_cache/
+.pytest-audit/
+.mypy_cache/
+.ruff_cache/
+.venv/
+.venv-*/
+venv/
+.env
+# Rust TUI workspace (Apache-2.0 fork under tui/)
+tui/target/
+**/*.rs.bk
+
+# Benchmark evaluation cache and trial artifacts
+.cache/
+.pi-eval/
+
+# Temporary files, coverage and logs
+*.log
+*.tmp
+*.bak
+*.swp
+*.orig
+.coverage
+.coverage.*
+coverage.xml
+htmlcov/
+

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pi-agent-cli-lc
-Version: 0.2.0
+Version: 0.3.0
 Summary: Standard ACP agent over AgentHarness (no x.ai extensions)
 Project-URL: Homepage, https://github.com/zy1233/pi-python
 Project-URL: Repository, https://github.com/zy1233/pi-python
@@ -20,8 +20,8 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: agent-client-protocol>=0.12.0
-Requires-Dist: pi-agent-core-lc==0.2.0
-Requires-Dist: pi-agent-harness-lc==0.2.0
+Requires-Dist: pi-agent-core-lc==0.3.0
+Requires-Dist: pi-agent-harness-lc==0.3.0
 Requires-Dist: pydantic>=2.0
 Description-Content-Type: text/markdown
 
@@ -31,6 +31,7 @@ Standard [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) agent o
 
 - stdio entry: `python -m pi_agent_cli` (or console script `pi-agent-cli`)
 - headless one-shot: `python -m pi_agent_cli -p "..."` 
+- Headless prompt overrides (override `agent.toml` `[prompt]`): `--system-prompt`, `--system-prompt-file`, `--append-system-prompt` / `--rules`, `--append-system-prompt-file`, `--no-context-files`
 - Config: `~/.pi-python/agent.toml` (see `agent.example.toml` in this directory)
 - No `x.ai/*` vendor RPCs — core + harness + ACP only
 

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.3.0}/README.md

@@ -4,6 +4,7 @@ Standard [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) agent o
 
 - stdio entry: `python -m pi_agent_cli` (or console script `pi-agent-cli`)
 - headless one-shot: `python -m pi_agent_cli -p "..."` 
+- Headless prompt overrides (override `agent.toml` `[prompt]`): `--system-prompt`, `--system-prompt-file`, `--append-system-prompt` / `--rules`, `--append-system-prompt-file`, `--no-context-files`
 - Config: `~/.pi-python/agent.toml` (see `agent.example.toml` in this directory)
 - No `x.ai/*` vendor RPCs — core + harness + ACP only
 

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.3.0}/agent.example.toml

@@ -20,3 +20,10 @@ paths = ["~/.pi-python/skills", ".pi/skills"]
 [agent]
 # Used by the Rust TUI when PI_AGENT_COMMAND is unset (Windows: prefer a venv python.exe).
 command = "python -m pi_agent_cli"
+
+[prompt]
+# no_context_files = false
+# custom_system_prompt = "You are a helpful assistant."
+# custom_system_prompt_file = "~/.pi-python/agent/SYSTEM.md"
+# append_system_prompt = "Always run tests after edits."
+# append_system_prompt_file = "~/.pi-python/agent/APPEND_SYSTEM.md"

pi_agent_cli_lc-0.3.0/pi_agent_cli/__main__.py

@@ -0,0 +1,151 @@
+"""stdio entry: python -m pi_agent_cli
+
+Default: ACP agent on stdio.
+`python -m pi_agent_cli -p "..."`: one-shot headless turn (no TUI).
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+from acp import run_agent
+
+from pi_agent_cli.agent import PiAcpAgent
+from pi_agent_cli.config import load_local_env
+from pi_agent_cli.headless import HeadlessPromptOverrides, resolve_print_prompt, run_print
+
+_PROMPT_CLI_FLAG_NAMES = (
+    "system_prompt",
+    "system_prompt_file",
+    "append_system_prompt",
+    "append_system_prompt_file",
+    "no_context_files",
+)
+
+
+async def _amain() -> None:
+    await run_agent(PiAcpAgent())
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pi-agent-cli",
+        description="Standard ACP agent over AgentHarness (stdio), or one-shot -p print.",
+    )
+    src = parser.add_mutually_exclusive_group()
+    src.add_argument(
+        "-p",
+        "--print",
+        dest="print_prompt",
+        metavar="PROMPT",
+        help="Run one prompt, print the assistant text, and exit (no TUI, no ACP stdio).",
+    )
+    src.add_argument(
+        "--prompt-json",
+        metavar="JSON",
+        help="Single-turn prompt as a JSON string or list of content blocks.",
+    )
+    src.add_argument(
+        "--prompt-file",
+        metavar="PATH",
+        type=Path,
+        help="Read the single-turn prompt from a file.",
+    )
+    parser.add_argument(
+        "--cwd",
+        metavar="PATH",
+        type=Path,
+        help="Working directory for the headless session (default: process cwd).",
+    )
+    system = parser.add_mutually_exclusive_group()
+    system.add_argument(
+        "--system-prompt",
+        "--system-prompt-override",
+        dest="system_prompt",
+        metavar="TEXT",
+        help="Replace the default system prompt (headless only).",
+    )
+    system.add_argument(
+        "--system-prompt-file",
+        metavar="PATH",
+        type=Path,
+        help="Read the system prompt override from a file (headless only).",
+    )
+    append = parser.add_mutually_exclusive_group()
+    append.add_argument(
+        "--append-system-prompt",
+        "--rules",
+        dest="append_system_prompt",
+        metavar="TEXT",
+        help="Append text to the system prompt (headless only).",
+    )
+    append.add_argument(
+        "--append-system-prompt-file",
+        metavar="PATH",
+        type=Path,
+        help="Read append text from a file (headless only).",
+    )
+    parser.add_argument(
+        "--no-context-files",
+        action="store_true",
+        help="Skip AGENTS.md / CLAUDE.md discovery (headless only).",
+    )
+    return parser
+
+
+def _prompt_overrides_from_args(args: argparse.Namespace) -> HeadlessPromptOverrides:
+    return HeadlessPromptOverrides(
+        system_prompt=args.system_prompt,
+        system_prompt_file=args.system_prompt_file,
+        append_system_prompt=args.append_system_prompt,
+        append_system_prompt_file=args.append_system_prompt_file,
+        no_context_files=True if args.no_context_files else None,
+    )
+
+
+def _has_prompt_cli_flags(args: argparse.Namespace) -> bool:
+    return any(getattr(args, name) for name in _PROMPT_CLI_FLAG_NAMES)
+
+
+def main() -> None:
+    load_local_env()
+    parser = _build_parser()
+    args = parser.parse_args()
+    headless = any(
+        value is not None for value in (args.print_prompt, args.prompt_json, args.prompt_file)
+    )
+    if not headless and _has_prompt_cli_flags(args):
+        print(
+            "error: --system-prompt, --append-system-prompt, and --no-context-files "
+            "require headless mode (-p, --prompt-json, or --prompt-file)",
+            file=sys.stderr,
+        )
+        raise SystemExit(2)
+    if headless:
+        try:
+            prompt = resolve_print_prompt(
+                print_prompt=args.print_prompt,
+                prompt_json=args.prompt_json,
+                prompt_file=args.prompt_file,
+            )
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            raise SystemExit(2) from exc
+        raise SystemExit(
+            asyncio.run(
+                run_print(
+                    prompt,
+                    cwd=args.cwd,
+                    prompt_overrides=_prompt_overrides_from_args(args),
+                )
+            )
+        )
+    asyncio.run(_amain())
+
+
+if __name__ == "__main__":
+    main()

{pi_agent_cli_lc-0.2.0 → pi_agent_cli_lc-0.3.0}/pi_agent_cli/agent.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import asyncio
+from dataclasses import replace
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from acp import PROTOCOL_VERSION, RequestError
 from acp.interfaces import Agent, Client
@@ -25,6 +26,7 @@ from acp.schema import (
     PromptCapabilities,
     PromptResponse,
     ResourceContentBlock,
+    ResumeSessionResponse,
     SessionCapabilities,
     SessionCloseCapabilities,
     SessionInfo,
@@ -34,8 +36,8 @@ from acp.schema import (
     TextContentBlock,
 )
 
-from pi_agent_cli.config import CliConfig, load_config, pi_home
-from pi_agent_cli.events import project_event
+from pi_agent_cli.config import CliConfig, PermissionMode, load_config, pi_home
+from pi_agent_cli.events import project_event, project_message_replay
 from pi_agent_cli.factory import create_session_harness, default_stream_fn, load_session_resources
 from pi_agent_cli.permissions import (
     PERMISSION_OPTIONS,
@@ -111,7 +113,7 @@ class PiAcpAgent(Agent):
         session = await self._repo.create({"cwd": cwd})
         session_id = (await session.get_metadata()).id
         await self._bind_session(session_id, session, cwd)
-        return NewSessionResponse(session_id=session_id)
+        return NewSessionResponse(session_id=session_id, field_meta=self._session_response_meta())
 
     async def load_session(
         self,
@@ -126,7 +128,12 @@ class PiAcpAgent(Agent):
             raise RequestError.resource_not_found(session_id)
         session = await self._repo.open(metadata)
         await self._bind_session(session_id, session, metadata.cwd or cwd)
-        return LoadSessionResponse()
+        if self._conn is not None:
+            context = await session.build_context()
+            for msg in context.messages:
+                for update in project_message_replay(msg):
+                    await self._conn.session_update(session_id=session_id, update=update)
+        return LoadSessionResponse(field_meta=self._session_response_meta())
 
     async def list_sessions(
         self, cwd: str | None = None, cursor: str | None = None, **kwargs: Any
@@ -143,6 +150,22 @@ class PiAcpAgent(Agent):
         ]
         return ListSessionsResponse(sessions=sessions)
 
+    async def resume_session(
+        self,
+        session_id: str,
+        cwd: str,
+        additional_directories: list[str] | None = None,
+        mcp_servers: list[HttpMcpServer | SseMcpServer | McpServerStdio] | None = None,
+        **kwargs: Any,
+    ) -> ResumeSessionResponse:
+        metadata = await self._find_metadata(session_id)
+        if metadata is None:
+            raise RequestError.resource_not_found(session_id)
+        session = await self._repo.open(metadata)
+        await self._bind_session(session_id, session, metadata.cwd or cwd)
+        # ACP session/resume intentionally does not replay history.
+        return ResumeSessionResponse(field_meta=self._session_response_meta())
+
     async def close_session(self, session_id: str, **kwargs: Any) -> CloseSessionResponse | None:
         self._harnesses.pop(session_id, None)
         return CloseSessionResponse()
@@ -178,11 +201,42 @@ class PiAcpAgent(Agent):
         task.add_done_callback(self._abort_tasks.discard)
 
     async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        if method == "pi/session/delete":
+            session_id_raw = params.get("sessionId", params.get("session_id"))
+            if not isinstance(session_id_raw, str) or not session_id_raw.strip():
+                raise RequestError.invalid_params(
+                    {"reason": "sessionId is required", "method": method}
+                )
+            session_id = session_id_raw.strip()
+            metadata = await self._find_metadata(session_id)
+            harness = self._harnesses.pop(session_id, None)
+            if harness is not None:
+                await harness.abort()
+            # Idempotent delete: missing session still returns success.
+            if metadata is not None:
+                await self._repo.delete(metadata)
+            return {"sessionId": session_id, "deleted": True}
         raise RequestError.method_not_found(method)
 
     async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
+        mode = _permission_mode_from_notification(method, params)
+        if mode is not None:
+            self._config = replace(self._config, permission=mode)
         return None
 
+    def _session_response_meta(self) -> dict[str, Any] | None:
+        model_id = self._config.model_id.strip()
+        if not model_id:
+            return None
+        meta: dict[str, Any] = {
+            "pi/currentModelId": model_id,
+            "pi/currentModelDisplayName": model_id,
+        }
+        provider = self._config.provider.strip()
+        if provider:
+            meta["pi/provider"] = provider
+        return meta
+
     def _require_harness(self, session_id: str) -> AgentHarness:
         harness = self._harnesses.get(session_id)
         if harness is None:
@@ -204,7 +258,7 @@ class PiAcpAgent(Agent):
             return await self._handle_tool_call(session_id, event)
 
         resources = await load_session_resources(cwd=cwd, config=self._config)
-        harness = create_session_harness(
+        harness = await create_session_harness(
             session=session,
             cwd=cwd,
             config=self._config,
@@ -287,11 +341,43 @@ def _prompt_to_text_images(
 
 
 def _stop_reason(message: Any) -> str:
+    """Map internal AssistantMessage stopReason to ACP PromptResponse stop_reason.
+
+    ACP stopReason enum: 'end_turn' | 'max_tokens' | 'max_turn_requests' | 'refusal' | 'cancelled'.
+    Internal stopReason values: 'stop' | 'length' | 'toolUse' | 'error' | 'aborted'.
+    """
     reason = getattr(message, "stopReason", None) or "stop"
     if reason == "aborted":
         return "cancelled"
     if reason == "length":
         return "max_tokens"
     if reason == "error":
-        return "refusal"
+        err = str(getattr(message, "errorMessage", "") or "")
+        if any(w in err.lower() for w in ("refus", "policy", "filter", "safety")):
+            return "refusal"
+        return "end_turn"
     return "end_turn"
+
+
+def _permission_mode_from_notification(
+    method: str, params: dict[str, Any] | None
+) -> PermissionMode | None:
+    """Best-effort permission mode sync for live sessions.
+
+    TUI settings changes are sent as extension notifications; we accept known
+    suffixes and update in-memory mode so the next tool call in this process
+    uses the new policy immediately.
+    """
+    suffix = method.rsplit("/", 1)[-1].strip().lower()
+    if suffix not in {"yolo_mode_changed", "permission_mode_changed"}:
+        return None
+    payload = params or {}
+    raw = payload.get("permission_mode")
+    if raw is None:
+        raw = payload.get("permissionMode")
+    if not isinstance(raw, str):
+        return None
+    normalized = raw.strip().lower()
+    if normalized not in {"ask", "auto", "always-approve"}:
+        return None
+    return cast(PermissionMode, normalized)

pi_agent_cli_lc-0.3.0/pi_agent_cli/benchmarks/__init__.py

@@ -0,0 +1,56 @@
+"""Benchmark evaluation subsystem for pi-agent-cli and pi-python harness."""
+
+from pi_agent_cli.benchmarks.collector import (
+    format_markdown_report,
+    print_summary_table,
+    save_summary_artifacts,
+)
+from pi_agent_cli.benchmarks.egress_policy import (
+    OFFICIAL_ALLOWED_HOSTS,
+    EgressPolicy,
+    resolve_task_egress_policy,
+)
+from pi_agent_cli.benchmarks.evaluator import run_trial
+from pi_agent_cli.benchmarks.golden_seed import (
+    get_seed_dir,
+    is_seed_ready,
+    load_golden_manifest,
+    provision_golden_seeds,
+)
+from pi_agent_cli.benchmarks.models import (
+    BenchmarkSummary,
+    BenchmarkTask,
+    TrialResult,
+)
+from pi_agent_cli.benchmarks.pelican import (
+    PELICAN_PROMPT,
+    PelicanSvgReport,
+    extract_svg,
+    save_pelican_artifact,
+    validate_pelican_svg,
+)
+from pi_agent_cli.benchmarks.task_loader import discover_tasks, load_task_from_dir
+
+__all__ = [
+    "OFFICIAL_ALLOWED_HOSTS",
+    "PELICAN_PROMPT",
+    "BenchmarkSummary",
+    "BenchmarkTask",
+    "EgressPolicy",
+    "PelicanSvgReport",
+    "TrialResult",
+    "discover_tasks",
+    "extract_svg",
+    "format_markdown_report",
+    "get_seed_dir",
+    "is_seed_ready",
+    "load_golden_manifest",
+    "load_task_from_dir",
+    "print_summary_table",
+    "provision_golden_seeds",
+    "resolve_task_egress_policy",
+    "run_trial",
+    "save_pelican_artifact",
+    "save_summary_artifacts",
+    "validate_pelican_svg",
+]

pi_agent_cli_lc-0.3.0/pi_agent_cli/benchmarks/collector.py

@@ -0,0 +1,130 @@
+"""Report collector and summarizer for benchmark evaluations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pi_agent_cli.benchmarks.models import BenchmarkSummary
+
+
+def format_markdown_report(summary: BenchmarkSummary) -> str:
+    """Generate a clean Markdown evaluation report."""
+    pass_pct = f"{summary.pass_rate * 100:.1f}%"
+    cache_pct = f"{summary.typical_cache_hit_rate * 100:.1f}%"
+    cost_per_pass = (
+        f"${summary.effective_cost_per_pass:.4f}"
+        if summary.effective_cost_per_pass is not None
+        else "N/A"
+    )
+    tokens_per_pass = (
+        f"{summary.tokens_per_solved:,.0f}" if summary.tokens_per_solved is not None else "N/A"
+    )
+
+    md = [
+        f"# Benchmark Evaluation Report: {summary.run_id}",
+        "",
+        f"- **Harness**: `{summary.harness}`",
+        f"- **Model**: `{summary.model}` ({summary.provider})",
+        f"- **Time**: `{summary.started_at}` to `{summary.finished_at}`",
+        f"- **Tasks**: {summary.successful_tasks} / {summary.completed_tasks} passed ({pass_pct})",
+        "",
+        "## Key Metrics",
+        "",
+        "| Metric | Value | Meaning |",
+        "| :--- | :--- | :--- |",
+        f"| **Pass Rate** | **{pass_pct}** | Solved and verified tasks |",
+        f"| **Effective Cost / Pass** | **{cost_per_pass}** | Amortized cost per passed task |",
+    ]
+    if summary.effective_cost_per_pass_kimi_k3 is not None:
+        md.append(
+            f"| **Normalized Cost / Pass (Kimi K3)** | "
+            f"**${summary.effective_cost_per_pass_kimi_k3:.4f}** | "
+            "Amortized cost normalized to official benchmark pricing |"
+        )
+    md.extend(
+        [
+            f"| **Tokens / Solved** | **{tokens_per_pass}** | Amortized tokens per passed task |",
+            f"| **Total Cost** | ${summary.total_cost_usd:.4f} | Total API spend for the run |",
+            f"| **Typical Cache Hit Rate** | {cache_pct} | Prompt caching efficiency |",
+            f"| **Mean Turns** | {summary.mean_turns:.1f} | Average interaction turns |",
+            (
+                f"| **Mean No-Action Turns** | {summary.mean_no_action_turns:.1f} | "
+                "Turns without file/shell operations (overhead) |"
+            ),
+            (
+                f"| **Median Duration** | {summary.median_duration_seconds:.1f}s | "
+                "Median elapsed time |"
+            ),
+            "",
+            "## Task Results",
+            "",
+            (
+                "| Status | Task ID | Duration | Turns (No-Act) | "
+                "Tokens | Cache | Cost | Norm Cost (K3) |"
+            ),
+            "| :---: | :--- | :---: | :---: | :---: | :---: | :---: | :---: |",
+        ]
+    )
+
+    for t in summary.trials:
+        icon = "✅" if t.success else "❌"
+        cache_str = f"{t.cache_hit_rate_normalized * 100:.0f}%"
+        k3_cost = (
+            f"${t.cost_kimi_k3_normalized_usd:.4f}"
+            if t.cost_kimi_k3_normalized_usd is not None
+            else "N/A"
+        )
+        md.append(
+            f"| {icon} | `{t.id}` | {t.duration_seconds:.1f}s | "
+            f"{t.turns} ({t.no_action_turns}) | {t.total_tokens:,} | "
+            f"{cache_str} | ${t.cost_first_cold_usd:.4f} | {k3_cost} |"
+        )
+
+    md.append("")
+    return "\n".join(md)
+
+
+def print_summary_table(summary: BenchmarkSummary) -> None:
+    """Print an ASCII table of results to standard output."""
+    pass_pct = f"{summary.pass_rate * 100:.1f}%"
+    cost_per_pass = (
+        f"${summary.effective_cost_per_pass:.4f}"
+        if summary.effective_cost_per_pass is not None
+        else "N/A"
+    )
+
+    print("\n" + "=" * 70)
+    print(f"  BENCHMARK RUN SUMMARY: {summary.run_id}")
+    print(f"  Model: {summary.provider}:{summary.model}")
+    print("=" * 70)
+    print(f"  Passed:         {summary.successful_tasks}/{summary.completed_tasks} ({pass_pct})")
+    print(f"  Effective Cost: {cost_per_pass}")
+    if summary.effective_cost_per_pass_kimi_k3 is not None:
+        print(f"  Norm Cost (K3): ${summary.effective_cost_per_pass_kimi_k3:.4f}")
+    print(f"  Total Cost:     ${summary.total_cost_usd:.4f}")
+    print(f"  Typical Cache:  {summary.typical_cache_hit_rate * 100:.1f}%")
+    print(f"  Mean Turns (No-Act):   {summary.mean_turns:.1f} ({summary.mean_no_action_turns:.1f})")
+    print("-" * 70)
+    print(f"  {'Status':<8} {'Task ID':<30} {'Turns':<8} {'Tokens':<10} {'Cost':<10}")
+    print("-" * 70)
+    for t in summary.trials:
+        stat = "PASS" if t.success else "FAIL"
+        cost_str = f"${t.cost_first_cold_usd:<9.4f}"
+        print(f"  {stat:<8} {t.title:<30} {t.turns:<8} {t.total_tokens:<10} {cost_str}")
+    print("=" * 70 + "\n")
+
+
+def save_summary_artifacts(
+    summary: BenchmarkSummary,
+    output_dir: Path,
+) -> Path:
+    """Save summary JSON and Markdown report into output directory."""
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    summary_json_path = output_dir / "eval-summary.json"
+    summary_json_path.write_text(summary.to_json(indent=2), encoding="utf-8")
+
+    report_md_path = output_dir / "REPORT.md"
+    report_md_path.write_text(format_markdown_report(summary), encoding="utf-8")
+
+    return report_md_path