agentpool-cli 0.1.0__py3-none-any.whl

agentpool/__init__.py

@@ -0,0 +1,3 @@
+"""AgentPool local agent control plane."""
+
+__version__ = "0.1.0"

agentpool/agent_io.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import secrets
+from pathlib import Path
+from typing import Any, Literal
+
+from agentpool.models import ToolError
+
+Detail = Literal["summary", "excerpt", "full"]
+
+DETAILS: set[str] = {"summary", "excerpt", "full"}
+EXCERPT_CHARS = 1600
+FULL_CHARS = 8000
+RAW_ARTIFACT_KINDS = {"transcript", "events", "screen", "summary", "result", "diff"}
+
+
+def parse_detail(value: str) -> Detail:
+    normalized = value.strip().lower()
+    if normalized in DETAILS:
+        return normalized  # type: ignore[return-value]
+    raise ToolError(
+        "INVALID_DETAIL",
+        "Detail must be summary, excerpt, or full.",
+        {"detail": value, "example": "--detail excerpt"},
+    )
+
+
+def read_stdin_text(stdin_text: str, label: str, example: str) -> str:
+    text = stdin_text.strip()
+    if text:
+        return text
+    raise ToolError(
+        "INVALID_STDIN",
+        f"No {label} was provided on stdin.",
+        {"example": example},
+    )
+
+
+def wrap_untrusted(text: str, detail: Detail) -> dict[str, Any]:
+    limit = EXCERPT_CHARS if detail == "excerpt" else FULL_CHARS
+    token = secrets.token_hex(8)
+    begin = f"BEGIN_UNTRUSTED_WORKER_OUTPUT_{token}"
+    end = f"END_UNTRUSTED_WORKER_OUTPUT_{token}"
+    clipped = tail_text(text, limit)
+    escaped = clipped.replace(begin, f"ESCAPED_{begin}").replace(end, f"ESCAPED_{end}")
+    return {
+        "included": True,
+        "detail": detail,
+        "truncated": len(text.strip()) > len(clipped),
+        "chars": len(escaped),
+        "text": f"{begin}\n{escaped}\n{end}",
+    }
+
+
+def omitted_worker_output(detail: Detail, lockdown: bool = False) -> dict[str, Any]:
+    reason = "lockdown" if lockdown else f"detail={detail}"
+    return {"included": False, "detail": detail, "reason": reason}
+
+
+def tail_text(text: str, limit: int) -> str:
+    stripped = text.strip()
+    if len(stripped) <= limit:
+        return stripped
+    return stripped[-limit:]
+
+
+def compact_artifact_manifest(manifest: dict[str, Any], lockdown: bool = False) -> dict[str, Any]:
+    files = []
+    for file in manifest.get("files") or []:
+        files.append(gate_raw_artifact(file, lockdown))
+    return {
+        "session_id": manifest.get("session_id"),
+        "artifact_dir": manifest.get("artifact_dir"),
+        "files": files,
+    }
+
+
+def observe_payload(
+    response: dict[str, Any],
+    artifact_manifest: dict[str, Any],
+    detail: Detail,
+    lockdown: bool = False,
+) -> dict[str, Any]:
+    payload = {
+        "session_id": response.get("session_id"),
+        "state": response.get("state"),
+        "event": response.get("event"),
+        "confidence": response.get("confidence"),
+        "metadata": response.get("metadata") or {},
+        "artifact_manifest": compact_artifact_manifest(artifact_manifest, lockdown=lockdown),
+    }
+    if response.get("parsed_question") and detail != "summary" and not lockdown:
+        payload["parsed_question"] = wrap_untrusted(str(response["parsed_question"]), "excerpt")
+    else:
+        payload["parsed_question_available"] = bool(response.get("parsed_question"))
+    text = response.get("screen_excerpt") or response.get("recent_log") or ""
+    if detail == "summary" or lockdown or not text:
+        payload["worker_output"] = omitted_worker_output(detail, lockdown)
+    else:
+        payload["worker_output"] = wrap_untrusted(str(text), detail)
+    return payload
+
+
+def collect_payload(result: dict[str, Any], detail: Detail, lockdown: bool = False) -> dict[str, Any]:
+    payload = {
+        "session_id": result.get("session_id"),
+        "state": result.get("state"),
+        "artifact_dir": result.get("artifact_dir"),
+        "artifacts": [gate_raw_artifact(artifact, lockdown) for artifact in result.get("artifacts") or []],
+        "git": result.get("git"),
+    }
+    summary = str(result.get("summary") or "")
+    if detail == "summary" or lockdown or not summary:
+        payload["worker_output"] = omitted_worker_output(detail, lockdown)
+    else:
+        payload["worker_output"] = wrap_untrusted(summary, detail)
+    return payload
+
+
+def lockdown_resource(path: str | Path, kind: str) -> dict[str, Any]:
+    return {
+        "blocked": True,
+        "reason": "lockdown",
+        "kind": kind,
+        "path": str(path),
+    }
+
+
+def gate_raw_artifact(artifact: dict[str, Any], lockdown: bool) -> dict[str, Any]:
+    row = dict(artifact)
+    if lockdown and row.get("kind") in RAW_ARTIFACT_KINDS:
+        row["gated"] = True
+        row["gated_reason"] = "lockdown"
+    return row

agentpool/artifacts.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from agentpool.event_detection import extract_result_body
+from agentpool.git_worktree import changed_files, git_diff, git_status, is_git_repo
+from agentpool.models import AgentSession, ArtifactRecord
+from agentpool.redaction import redact_text
+from agentpool.utils import repo_hash, sha256_file, write_json
+
+
+def create_artifact_dir(root: Path, repo_path: Path, session_id: str) -> Path:
+    artifact_dir = root / repo_hash(repo_path) / session_id
+    (artifact_dir / "raw" / "tmux-captures").mkdir(parents=True, exist_ok=True)
+    return artifact_dir
+
+
+def initialize_artifacts(session: AgentSession, prompt: str) -> None:
+    artifact_dir = Path(session.artifact_dir)
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    Path(session.transcript_path).write_text("", encoding="utf-8")
+    Path(session.events_path).write_text("", encoding="utf-8")
+    (artifact_dir / "prompt.md").write_text(prompt, encoding="utf-8")
+    write_json(artifact_dir / "metadata.json", session.model_dump(mode="json"))
+
+
+def append_transcript(session: AgentSession, text: str) -> None:
+    path = Path(session.transcript_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    if text and text not in existing[-max(len(text), 1) :]:
+        with path.open("a", encoding="utf-8") as fh:
+            if existing and not existing.endswith("\n"):
+                fh.write("\n")
+            fh.write(text)
+            if not text.endswith("\n"):
+                fh.write("\n")
+
+
+def collect_artifacts(session: AgentSession, screen: str, include_diff: bool = True) -> dict[str, Any]:
+    artifact_dir = Path(session.artifact_dir)
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    (artifact_dir / "latest_screen.txt").write_text(screen, encoding="utf-8")
+    append_transcript(session, screen)
+    workdir = Path(session.worktree_path or session.repo_path)
+    status_text = git_status(workdir)
+    diff_text = redact_text(git_diff(workdir)) if include_diff else ""
+    (artifact_dir / "git-status.txt").write_text(status_text, encoding="utf-8")
+    if include_diff:
+        (artifact_dir / "diff.patch").write_text(diff_text, encoding="utf-8")
+    summary = materialize_result_artifacts(session, screen) or "No AGENTPOOL result marker found."
+    (artifact_dir / "summary.md").write_text(summary, encoding="utf-8")
+    (artifact_dir / "result.md").write_text(summary, encoding="utf-8")
+    write_json(
+        artifact_dir / "metadata.json",
+        {
+            **session.model_dump(mode="json"),
+            "git": {
+                "is_repo": is_git_repo(workdir),
+                "dirty": bool(status_text.strip()),
+                "changed_files": changed_files(workdir) if is_git_repo(workdir) else [],
+            },
+        },
+    )
+    artifacts: list[ArtifactRecord] = []
+    for kind, filename in [
+        ("metadata", "metadata.json"),
+        ("prompt", "prompt.md"),
+        ("transcript", "transcript.txt"),
+        ("events", "events.jsonl"),
+        ("screen", "latest_screen.txt"),
+        ("summary", "summary.md"),
+        ("result", "result.md"),
+        ("git_status", "git-status.txt"),
+        ("diff", "diff.patch"),
+    ]:
+        path = artifact_dir / filename
+        if path.exists():
+            artifacts.append(ArtifactRecord(kind=kind, path=str(path), sha256=sha256_file(path)))
+    return {
+        "session_id": session.id,
+        "state": session.state.value if hasattr(session.state, "value") else session.state,
+        "artifact_dir": str(artifact_dir),
+        "artifacts": [artifact.model_dump(mode="json") for artifact in artifacts],
+        "summary": summary,
+        "git": {
+            "is_repo": is_git_repo(workdir),
+            "dirty": bool(status_text.strip()),
+            "changed_files": changed_files(workdir) if is_git_repo(workdir) else [],
+        },
+    }
+
+
+def artifact_manifest(session: AgentSession) -> dict[str, Any]:
+    materialize_result_artifacts(session)
+    artifact_dir = Path(session.artifact_dir)
+    files = []
+    for kind, filename in [
+        ("metadata", "metadata.json"),
+        ("prompt", "prompt.md"),
+        ("transcript", "transcript.txt"),
+        ("events", "events.jsonl"),
+        ("screen", "latest_screen.txt"),
+        ("summary", "summary.md"),
+        ("result", "result.md"),
+        ("git_status", "git-status.txt"),
+        ("diff", "diff.patch"),
+    ]:
+        path = artifact_dir / filename
+        files.append(
+            {
+                "kind": kind,
+                "path": str(path),
+                "exists": path.exists(),
+                "sha256": sha256_file(path) if path.exists() else None,
+            }
+        )
+    return {
+        "session_id": session.id,
+        "artifact_dir": str(artifact_dir),
+        "files": files,
+    }
+
+
+def materialize_result_artifacts(session: AgentSession, screen: str = "") -> str | None:
+    artifact_dir = Path(session.artifact_dir)
+    candidates = [screen]
+    latest_screen = artifact_dir / "latest_screen.txt"
+    if latest_screen.exists():
+        candidates.append(latest_screen.read_text(encoding="utf-8"))
+    transcript = Path(session.transcript_path)
+    if transcript.exists():
+        candidates.append(transcript.read_text(encoding="utf-8"))
+    for candidate in candidates:
+        summary = extract_result(candidate)
+        if summary:
+            artifact_dir.mkdir(parents=True, exist_ok=True)
+            (artifact_dir / "summary.md").write_text(summary, encoding="utf-8")
+            (artifact_dir / "result.md").write_text(summary, encoding="utf-8")
+            return summary
+    return None
+
+
+def extract_result(screen: str) -> str | None:
+    body = extract_result_body(screen)
+    if body:
+        return body
+    if "AGENTPOOL_SMOKE_DONE" in screen:
+        return "AGENTPOOL_SMOKE_DONE"
+    return None