pcode 0.1.0__py3-none-any.whl

pcode/workers.py

@@ -0,0 +1,136 @@
+"""Each delegated worker's own stream, kept for the read-only viewer; no terminal imports.
+
+The conversation's transcript shows a worker only as its delegate row and the
+calls beneath it. This keeps what the worker itself said and did, in order, so
+`/agents` can show it while it runs and after it settles. Memory only: nothing
+here is journaled, so a resumed session starts with no workers.
+"""
+
+from dataclasses import dataclass, field
+from time import monotonic
+
+from pcode.runtime import ChildPlan, ChildText, ToolStarted, ToolSummary
+from pcode.tool_display import PLAN_TOOLS
+
+DELEGATE = "delegate_task"
+# Workers accumulate over a long session; keep the recent ones.
+WORKER_HISTORY = 20
+
+
+@dataclass
+class WorkerEntry:
+    """One step of a worker's stream: a run of prose or reasoning, or one tool call."""
+
+    kind: str  # "text", "thinking" or "tool"
+    text: str = ""
+    tool: ToolStarted | ToolSummary | None = None
+
+
+@dataclass
+class Worker:
+    call_id: str
+    agent: str
+    task: str
+    started: float = field(default_factory=monotonic)
+    settled: float | None = None
+    failed: bool = False
+    # Why it stopped when that was not a normal finish, e.g. "Interrupted".
+    ending: str = ""
+    activity: str = ""
+    plan: list[dict] = field(default_factory=list)
+    entries: list[WorkerEntry] = field(default_factory=list)
+    # Bumped on every change, so a viewer can skip unchanged repaints.
+    version: int = 0
+
+    @property
+    def running(self) -> bool:
+        return self.settled is None
+
+    def elapsed(self) -> float:
+        return (self.settled if self.settled is not None else monotonic()) - self.started
+
+    def state(self) -> str:
+        if self.running:
+            return self.activity or "Starting"
+        return self.ending or ("Failed" if self.failed else "Done")
+
+    def add_text(self, event: ChildText) -> None:
+        kind = "thinking" if event.thinking else "text"
+        last = self.entries[-1] if self.entries else None
+        if event.start or last is None or last.kind != kind:
+            self.entries.append(WorkerEntry(kind, event.text))
+        else:
+            last.text += event.text
+
+    def add_tool(self, event: ToolStarted | ToolSummary) -> None:
+        """A start adds a row; its restatement or result replaces that row."""
+        for entry in reversed(self.entries):
+            if entry.tool is not None and entry.tool.call_id == event.call_id:
+                entry.tool = event
+                return
+        self.entries.append(WorkerEntry("tool", tool=event))
+
+
+@dataclass
+class Workers:
+    items: list[Worker] = field(default_factory=list)
+
+    def get(self, call_id: str) -> Worker | None:
+        return next((w for w in self.items if w.call_id == call_id), None)
+
+    def record(self, event) -> None:
+        """Fold one runtime event into the worker it belongs to, if any."""
+        if isinstance(event, ToolStarted | ToolSummary) and event.name == DELEGATE:
+            self._delegate(event)
+            return
+        call_id = (
+            event.call_id
+            if isinstance(event, ChildText | ChildPlan)
+            else event.parent_call_id
+            if isinstance(event, ToolStarted | ToolSummary)
+            else ""
+        )
+        worker = self.get(call_id) if call_id else None
+        if worker is None:
+            return
+        if isinstance(event, ChildText):
+            worker.add_text(event)
+        elif isinstance(event, ChildPlan):
+            worker.plan = event.items
+        elif event.name not in PLAN_TOOLS:
+            # The plan has its own section; its tool calls would only repeat it.
+            worker.add_tool(event)
+        worker.version += 1
+
+    def _delegate(self, event: ToolStarted | ToolSummary) -> None:
+        worker = self.get(event.call_id)
+        if isinstance(event, ToolStarted):
+            if worker is None:
+                worker = Worker(event.call_id, event.agent or "worker", event.task)
+                self.items.append(worker)
+                del self.items[:-WORKER_HISTORY]
+            # A restated start carries the worker's current phase.
+            worker.activity = event.activity
+        elif worker is not None and worker.running:
+            worker.settled = monotonic()
+            worker.failed = event.failed
+        else:
+            return
+        worker.version += 1
+
+    def end_turn(self) -> None:
+        """A turn that ends under a running worker stopped it, e.g. by cancellation."""
+        for worker in self.items:
+            if worker.running:
+                worker.settled = monotonic()
+                worker.failed = True
+                worker.ending = "Interrupted"
+                worker.version += 1
+
+    def running(self) -> int:
+        return sum(worker.running for worker in self.items)
+
+    def latest(self) -> Worker | None:
+        """The newest running worker, else the newest one."""
+        running = [worker for worker in self.items if worker.running]
+        return (running or self.items or [None])[-1]

pcode/workspace.py

@@ -0,0 +1,57 @@
+"""A workspace can be deleted while a session is still working in it.
+
+Session worktrees are removed from outside the session that owns them: another
+session merges and removes it, `/worktree clean` sweeps it, someone runs `git
+worktree prune`. Every tool in this process then resolves paths against a
+directory that is gone.
+
+Harness reports that as a retryable failure, on the assumption that the model
+destroyed its own working directory and can `cd` out of it. Here the working
+directory is the workspace, fixed for the whole run, so no command the model
+can write will succeed -- a `cd /tmp` prefix does not help, because the tool
+chdirs into the workspace before running it. Retrying only spends the tool
+budget and ends the turn with a message blaming the model. Stop on the first
+call instead, and name the directory that disappeared.
+"""
+
+from pathlib import Path
+
+from pydantic_ai.capabilities import AbstractCapability
+
+
+class WorkspaceGoneError(Exception):
+    """The workspace directory disappeared; nothing in the run can recover.
+
+    Deliberately not `ModelRetry`: the model has no move that fixes it.
+    """
+
+
+def require_workspace(workspace: Path) -> None:
+    """Raise `WorkspaceGoneError` unless tools can still run in `workspace`."""
+    if workspace.is_dir():
+        return
+    raise WorkspaceGoneError(
+        f"The workspace {workspace} no longer exists, so no tool can run in it. "
+        "It was deleted while this session was open, usually by a worktree removed "
+        "from elsewhere. Resume this conversation in another directory with "
+        "`pcode -C DIR --continue <session>`."
+    )
+
+
+class WorkspaceGuard(AbstractCapability):
+    """Check the workspace still exists before a run and before each tool call.
+
+    The run-start check comes first in the capability list, so it names the
+    missing directory before Harness's own capabilities fail on it with a
+    generic `WorkspaceUnavailableError`.
+    """
+
+    def __init__(self, workspace: Path) -> None:
+        self.workspace = Path(workspace)
+
+    async def before_run(self, ctx) -> None:
+        require_workspace(self.workspace)
+
+    async def wrap_tool_execute(self, ctx, *, call, tool_def, args, handler):
+        require_workspace(self.workspace)
+        return await handler(args)

pcode/workspace_filesystem.py

@@ -0,0 +1,72 @@
+"""Unconfined file paths with a stable workspace-relative base.
+
+Harness resolves relative paths from the workspace's working directory and
+reports walked paths relative to it; a `root_dir` of `/` lifts the boundary,
+so the workspace stays the base without being a sandbox. See
+dev/dependencies.md before upgrading the filesystem integration.
+"""
+
+from dataclasses import fields
+from pathlib import Path
+
+from pydantic_ai_harness.filesystem import FileSystem, FileSystemToolset
+
+
+def _any_depth(pattern: str) -> str:
+    """Match a protected-file pattern at any depth, since the root is `/`."""
+    return pattern if pattern.startswith("**/") else f"**/{pattern}"
+
+
+class WorkspaceFileSystem(FileSystem):
+    """Keep workspace-relative paths without using the workspace as a boundary."""
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        # Workspace paths are POSIX, so `/` is the whole filesystem on any host.
+        self.root_dir = "/"
+        # Protected-file rules still apply, including to paths outside the workspace.
+        self.read_only_patterns = [_any_depth(pattern) for pattern in self.read_only_patterns]
+
+    @classmethod
+    def from_filesystem(cls, filesystem: FileSystem) -> "WorkspaceFileSystem":
+        values = {f.name: getattr(filesystem, f.name) for f in fields(FileSystem) if f.init}
+        # Deprecated upstream aliases; passing them only re-triggers the warning.
+        values.pop("cwd", None)
+        values.pop("protected_patterns", None)
+        return cls(**values)
+
+    def get_instructions(self):
+        async def instructions(ctx) -> str:
+            base = await ctx.workspace.working_dir()
+            return (
+                f"File tools accept absolute paths anywhere on the host and relative paths "
+                f"based on the workspace {base!r}, including '..'. "
+                "Shell cd does not change that file-tool base. File tools are not a sandbox. "
+                "Search and listing tools default to the workspace. "
+                "Returned relative paths use that same workspace base. "
+                "Existing protected-file write rules still apply to file tools, not shell commands."
+            )
+
+        return instructions
+
+    def _toolset_type(self) -> type[FileSystemToolset]:
+        return FileSystemToolset
+
+    def _file_system_toolset(self) -> FileSystemToolset:
+        if self._toolset is None:
+            self._toolset = self._toolset_type()(
+                root_dir=Path(self.root_dir),
+                allowed_patterns=self.allowed_patterns,
+                denied_patterns=self.denied_patterns,
+                read_only_patterns=self.read_only_patterns,
+                max_read_lines=self.max_read_lines,
+                max_read_chars=self.max_read_chars,
+                max_list_results=self.max_list_results,
+                max_search_results=self.max_search_results,
+                max_find_results=self.max_find_results,
+                id=self.id or "file_system",
+                content_hashes=self.content_hashes,
+                tools=self.tools,
+                max_retries=self.max_retries,
+            )
+        return self._toolset