PyPI - agentpool-cli - Versions diffs - 0.1.0__py3-none-any.whl - Mend

agentpool-cli 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

agentpool/__init__.py +3 -0
agentpool/agent_io.py +134 -0
agentpool/artifacts.py +151 -0
agentpool/cli.py +1199 -0
agentpool/config.py +373 -0
agentpool/docs/agentpool-skill.md +85 -0
agentpool/docs/onboarding.md +169 -0
agentpool/event_detection.py +150 -0
agentpool/fixtures/__init__.py +1 -0
agentpool/fixtures/fake_agents/__init__.py +1 -0
agentpool/fixtures/fake_agents/fake_approval_agent.py +16 -0
agentpool/fixtures/fake_agents/fake_common.py +44 -0
agentpool/fixtures/fake_agents/fake_completed_agent.py +13 -0
agentpool/fixtures/fake_agents/fake_idle_agent.py +16 -0
agentpool/fixtures/fake_agents/fake_limit_agent.py +14 -0
agentpool/fixtures/fake_agents/fake_patch_agent.py +17 -0
agentpool/fixtures/fake_agents/fake_question_agent.py +16 -0
agentpool/git_worktree.py +144 -0
agentpool/mcp/__init__.py +1 -0
agentpool/mcp/resources.py +64 -0
agentpool/mcp/tools.py +259 -0
agentpool/mcp_server.py +487 -0
agentpool/models.py +310 -0
agentpool/onboarding.py +1279 -0
agentpool/policy.py +63 -0
agentpool/provider_model_catalog.json +997 -0
agentpool/providers/__init__.py +3 -0
agentpool/providers/base.py +411 -0
agentpool/providers/registry.py +139 -0
agentpool/redaction.py +30 -0
agentpool/runtimes/__init__.py +3 -0
agentpool/runtimes/base.py +36 -0
agentpool/runtimes/tmux.py +133 -0
agentpool/session_manager.py +1061 -0
agentpool/stats/__init__.py +6 -0
agentpool/stats/card.py +74 -0
agentpool/stats/compute.py +496 -0
agentpool/stats/queries.py +138 -0
agentpool/stats/render.py +103 -0
agentpool/stats/window.py +85 -0
agentpool/store.py +478 -0
agentpool/usage/__init__.py +1 -0
agentpool/usage/_common.py +223 -0
agentpool/usage/ccusage.py +130 -0
agentpool/usage/claude.py +23 -0
agentpool/usage/codex.py +210 -0
agentpool/usage/codexbar.py +186 -0
agentpool/usage/combine.py +71 -0
agentpool/usage/copilot.py +146 -0
agentpool/usage/devin.py +265 -0
agentpool/usage/parsers.py +41 -0
agentpool/usage/probes.py +52 -0
agentpool/usage/provider_parsers.py +276 -0
agentpool/usage/summary.py +166 -0
agentpool/utils.py +59 -0
agentpool_cli-0.1.0.dist-info/METADATA +292 -0
agentpool_cli-0.1.0.dist-info/RECORD +60 -0
agentpool_cli-0.1.0.dist-info/WHEEL +4 -0
agentpool_cli-0.1.0.dist-info/entry_points.txt +2 -0
agentpool_cli-0.1.0.dist-info/licenses/LICENSE +21 -0

agentpool/event_detection.py ADDED Viewed

@@ -0,0 +1,150 @@
+from __future__ import annotations
+import hashlib
+import re
+import textwrap
+from dataclasses import dataclass
+from agentpool.models import Confidence, ObserveEvent, SessionState
+QUESTION_PATTERNS = [
+    re.compile(r"Should I\b", re.I),
+    re.compile(r"Do you want\b", re.I),
+    re.compile(r"Which .* should I\b", re.I),
+    re.compile(r"^[^\n]{0,240}\?\s*$", re.I | re.M),
+]
+APPROVAL_PATTERNS = [
+    re.compile(r"Proceed\?", re.I),
+    re.compile(r"Continue\?", re.I),
+    re.compile(r"Do you trust\b", re.I),
+    re.compile(r"Hooks need review", re.I),
+    re.compile(r"Update available!", re.I),
+    re.compile(r"Allow .*\?", re.I),
+    re.compile(r"\[y/N\]", re.I),
+    re.compile(r"\(y/n\)", re.I),
+]
+OVERAGE_PATTERNS = [
+    re.compile(r"extra usage", re.I),
+    re.compile(r"overage", re.I),
+    re.compile(r"continue with paid", re.I),
+    re.compile(r"API credits", re.I),
+]
+LIMIT_PATTERNS = [
+    re.compile(r"approaching .*limit", re.I),
+    re.compile(r"limit reached", re.I),
+    re.compile(r"resets", re.I),
+]
+ERROR_PATTERNS = [
+    re.compile(r"command not found", re.I),
+    re.compile(r"not authenticated", re.I),
+    re.compile(r"login required", re.I),
+    re.compile(r"authentication required", re.I),
+    re.compile(r"press any key to log in", re.I),
+    re.compile(r"access denied.*invalid subscription", re.I | re.S),
+    re.compile(r"wrong API endpoint", re.I),
+    re.compile(r"unable to reach localhost", re.I),
+    re.compile(r"\btraceback\b", re.I),
+    re.compile(r"\bexception\b", re.I),
+    re.compile(r"\bpanic(?:ked)?\b", re.I),
+]
+DONE_PATTERN = re.compile(
+    r"^\s*(?:[•●-]\s*)?AGENTPOOL_RESULT_START\s*$(?P<body>.*?)"
+    r"^\s*(?:[•●-]\s*)?AGENTPOOL_RESULT_END\s*$",
+    re.I | re.M | re.S,
+)
+SMOKE_DONE_PATTERN = re.compile(r"\bAGENTPOOL_SMOKE_DONE\b", re.I)
+@dataclass(frozen=True)
+class Detection:
+    state: SessionState
+    event: ObserveEvent
+    confidence: Confidence
+    parsed_question: str | None = None
+def screen_hash(screen: str) -> str:
+    return hashlib.sha256(screen.encode("utf-8")).hexdigest()
+def trim_excerpt(screen: str, max_chars: int = 4000) -> str:
+    return screen.strip()[-max_chars:]
+def detect_event(screen: str, previous_hash: str | None = None) -> Detection:
+    excerpt = trim_excerpt(screen)
+    active_excerpt = trim_excerpt(screen, max_chars=1200)
+    approval_excerpt = _active_prompt_region(active_excerpt)
+    if SMOKE_DONE_PATTERN.search(_strip_prompt_lines(active_excerpt)):
+        return Detection(SessionState.COMPLETED, ObserveEvent.COMPLETED, Confidence.OBSERVED)
+    if extract_result_body(excerpt):
+        return Detection(SessionState.COMPLETED, ObserveEvent.COMPLETED, Confidence.OBSERVED)
+    for pattern in OVERAGE_PATTERNS:
+        if pattern.search(approval_excerpt):
+            return Detection(SessionState.AWAITING_APPROVAL, ObserveEvent.OVERAGE_PROMPT, Confidence.OBSERVED)
+    for pattern in LIMIT_PATTERNS:
+        if pattern.search(active_excerpt):
+            return Detection(SessionState.RUNNING, ObserveEvent.LIMIT_WARNING, Confidence.OBSERVED)
+    for pattern in APPROVAL_PATTERNS:
+        if pattern.search(approval_excerpt):
+            return Detection(SessionState.AWAITING_APPROVAL, ObserveEvent.APPROVAL_PROMPT, Confidence.OBSERVED)
+    for pattern in QUESTION_PATTERNS:
+        match = pattern.search(active_excerpt)
+        if match:
+            line = _line_for_match(active_excerpt, match.start())
+            return Detection(SessionState.AWAITING_USER_INPUT, ObserveEvent.QUESTION, Confidence.OBSERVED, line)
+    for pattern in ERROR_PATTERNS:
+        if pattern.search(active_excerpt):
+            return Detection(SessionState.FAILED, ObserveEvent.ERROR, Confidence.OBSERVED)
+    current_hash = screen_hash(screen)
+    if previous_hash and previous_hash != current_hash:
+        return Detection(SessionState.RUNNING, ObserveEvent.SCREEN_CHANGED, Confidence.OBSERVED)
+    return Detection(SessionState.RUNNING, ObserveEvent.NONE, Confidence.UNKNOWN)
+def _line_for_match(text: str, index: int) -> str:
+    start = text.rfind("\n", 0, index) + 1
+    end = text.find("\n", index)
+    if end == -1:
+        end = len(text)
+    return text[start:end].strip()
+def extract_result_body(screen: str) -> str | None:
+    for match in DONE_PATTERN.finditer(trim_excerpt(screen)):
+        body = match.group("body")
+        if _looks_like_actual_result(body):
+            return textwrap.dedent(body).strip()
+    return None
+def _looks_like_actual_result(body: str) -> bool:
+    lines = [line.strip() for line in body.splitlines() if line.strip()]
+    if not lines:
+        return False
+    for index, line in enumerate(lines):
+        if line.lower().startswith("summary"):
+            after_colon = line.split(":", 1)[1].strip() if ":" in line else ""
+            if after_colon:
+                return True
+            next_line = lines[index + 1].lower() if index + 1 < len(lines) else ""
+            return bool(next_line and not next_line.startswith("findings"))
+    return True
+def _strip_prompt_lines(text: str) -> str:
+    lines = []
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped.startswith(("❯", "›", ">")):
+            continue
+        lines.append(line)
+    return "\n".join(lines)
+def _active_prompt_region(text: str) -> str:
+    matches = list(re.finditer(r"(?m)^›\s+(?!\d+[.)]?\s)", text))
+    if not matches:
+        return text
+    return text[matches[-1].start() :]

agentpool/fixtures/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ """Packaged fixtures used by AgentPool smoke tests."""

agentpool/fixtures/fake_agents/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ """Fake provider scripts packaged for install-time smoke tests."""

agentpool/fixtures/fake_agents/fake_approval_agent.py ADDED Viewed

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from fake_common import print_result, read_initial_prompt
+def main() -> None:
+    print("Fake Approval Agent ready.")
+    read_initial_prompt()
+    print("Proceed? [y/N]")
+    answer = input()
+    print(f"Approval answer: {answer}")
+    print_result("Approval flow completed.")
+if __name__ == "__main__":
+    main()

agentpool/fixtures/fake_agents/fake_common.py ADDED Viewed

@@ -0,0 +1,44 @@
+from __future__ import annotations
+import sys
+import time
+sys.stdout.reconfigure(line_buffering=True)
+def read_initial_prompt() -> str:
+    lines: list[str] = []
+    saw_task = False
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            break
+        lines.append(line)
+        if saw_task:
+            break
+        if line.strip() == "Task:":
+            saw_task = True
+    return "".join(lines)
+def print_result(summary: str, files_changed: str = "None", blockers: str = "None") -> None:
+    print("AGENTPOOL_RESULT_START")
+    print("Summary:")
+    print(summary)
+    print("Findings:")
+    print("Fake provider completed.")
+    print("Files inspected:")
+    print("None")
+    print("Files changed:")
+    print(files_changed)
+    print("Commands run:")
+    print("fake-agent")
+    print("Tests run:")
+    print("None")
+    print("Blockers:")
+    print(blockers)
+    print("Confidence:")
+    print("high")
+    print("AGENTPOOL_RESULT_END")
+    time.sleep(30)

agentpool/fixtures/fake_agents/fake_completed_agent.py ADDED Viewed

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from fake_common import print_result, read_initial_prompt
+def main() -> None:
+    print("Fake Completed Agent ready.")
+    read_initial_prompt()
+    print_result("Completed immediately.")
+if __name__ == "__main__":
+    main()

agentpool/fixtures/fake_agents/fake_idle_agent.py ADDED Viewed

@@ -0,0 +1,16 @@
+from __future__ import annotations
+import time
+from fake_common import read_initial_prompt
+def main() -> None:
+    print("Fake Idle Agent ready.")
+    read_initial_prompt()
+    print("Working...")
+    time.sleep(30)
+if __name__ == "__main__":
+    main()

agentpool/fixtures/fake_agents/fake_limit_agent.py ADDED Viewed

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from fake_common import print_result, read_initial_prompt
+def main() -> None:
+    print("Fake Limit Agent ready.")
+    read_initial_prompt()
+    print("Approaching 5-hour limit - resets 5pm.")
+    print_result("Limit warning emitted.")
+if __name__ == "__main__":
+    main()

agentpool/fixtures/fake_agents/fake_patch_agent.py ADDED Viewed

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from pathlib import Path
+from fake_common import print_result, read_initial_prompt
+def main() -> None:
+    print("Fake Patch Agent ready.")
+    read_initial_prompt()
+    target = Path("agentpool_fake_patch.txt")
+    target.write_text("patched by fake agent\n", encoding="utf-8")
+    print_result("Patch file written.", files_changed=str(target))
+if __name__ == "__main__":
+    main()

agentpool/fixtures/fake_agents/fake_question_agent.py ADDED Viewed

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from fake_common import print_result, read_initial_prompt
+def main() -> None:
+    print("Fake Question Agent ready.")
+    read_initial_prompt()
+    print("I found two possible paths. Should I inspect migrations or auth middleware first?")
+    answer = input()
+    print(f"Steering received: {answer}")
+    print_result("Question path completed after steering.")
+if __name__ == "__main__":
+    main()

agentpool/git_worktree.py ADDED Viewed

@@ -0,0 +1,144 @@
+from __future__ import annotations
+import subprocess
+from pathlib import Path
+from agentpool.models import ToolError
+from agentpool.utils import run_capture
+def is_git_repo(path: Path) -> bool:
+    proc = run_capture(["git", "rev-parse", "--is-inside-work-tree"], cwd=path)
+    return proc.returncode == 0 and proc.stdout.strip() == "true"
+def git_status(path: Path) -> str:
+    if not is_git_repo(path):
+        return ""
+    return run_capture(["git", "status", "--porcelain"], cwd=path).stdout
+def git_diff(path: Path) -> str:
+    if not is_git_repo(path):
+        return ""
+    proc = run_capture(["git", "diff", "--binary"], cwd=path, timeout=30)
+    if proc.returncode == 124:
+        return "[agentpool] git diff timed out after 30s; diff omitted.\n"
+    if proc.returncode != 0:
+        return f"[agentpool] git diff failed: {proc.stderr.strip()}\n"
+    return proc.stdout
+def changed_files(path: Path) -> list[str]:
+    status = git_status(path)
+    return [line[3:] for line in status.splitlines() if len(line) > 3]
+def create_worktree(repo_path: Path, provider_id: str, session_id: str) -> Path:
+    if not is_git_repo(repo_path):
+        raise ToolError("GIT_NOT_REPO", "Worktree isolation requires a git repository.", {"repo_path": str(repo_path)})
+    parent = repo_path.parent / ".agentpool-worktrees"
+    parent.mkdir(parents=True, exist_ok=True)
+    worktree_path = parent / session_id
+    branch = agentpool_branch(provider_id, session_id)
+    proc = subprocess.run(
+        ["git", "worktree", "add", "-b", branch, str(worktree_path)],
+        cwd=str(repo_path),
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        raise ToolError(
+            "WORKTREE_FAILED",
+            "Failed to create git worktree.",
+            {"repo_path": str(repo_path), "stderr": proc.stderr, "branch": branch},
+        )
+    return worktree_path
+def agentpool_branch(provider_id: str, session_id: str) -> str:
+    safe_provider = "".join(ch if ch.isalnum() or ch in {"-", "_"} else "-" for ch in provider_id).strip("-")
+    return f"agentpool/{safe_provider}/{session_id[-6:]}"
+def delete_agentpool_branch(repo_path: Path, provider_id: str, session_id: str) -> dict[str, str | bool]:
+    if not is_git_repo(repo_path):
+        return {"deleted": False, "reason": "not_git_repo"}
+    branch = agentpool_branch(provider_id, session_id)
+    proc = subprocess.run(
+        ["git", "branch", "-D", branch],
+        cwd=str(repo_path),
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        return {"deleted": False, "branch": branch, "stderr": proc.stderr.strip()}
+    return {"deleted": True, "branch": branch}
+def list_agentpool_worktrees(repo_path: Path) -> list[dict[str, str | bool]]:
+    if not is_git_repo(repo_path):
+        return []
+    proc = subprocess.run(
+        ["git", "worktree", "list", "--porcelain"],
+        cwd=str(repo_path),
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if proc.returncode != 0:
+        return []
+    worktrees: list[dict[str, str | bool]] = []
+    current: dict[str, str | bool] = {}
+    for line in proc.stdout.splitlines():
+        if not line:
+            if _is_agentpool_worktree(current):
+                worktrees.append(current)
+            current = {}
+            continue
+        key, _, value = line.partition(" ")
+        if key == "worktree":
+            current["path"] = value
+        elif key == "branch":
+            current["branch"] = value
+        elif key == "HEAD":
+            current["head"] = value
+        elif key == "bare":
+            current["bare"] = True
+    if _is_agentpool_worktree(current):
+        worktrees.append(current)
+    return worktrees
+def cleanup_worktree(repo_path: Path, worktree_path: Path, force: bool = False) -> dict[str, str | bool]:
+    if not is_git_repo(repo_path):
+        raise ToolError("GIT_NOT_REPO", "Worktree cleanup requires a git repository.", {"repo_path": str(repo_path)})
+    if not worktree_path.exists():
+        return {"removed": False, "path": str(worktree_path), "reason": "missing"}
+    dirty = bool(git_status(worktree_path).strip())
+    if dirty and not force:
+        raise ToolError(
+            "WORKTREE_DIRTY",
+            "Worktree has uncommitted changes; pass force to remove it.",
+            {"worktree_path": str(worktree_path)},
+        )
+    args = ["git", "worktree", "remove"]
+    if force:
+        args.append("--force")
+    args.append(str(worktree_path))
+    proc = subprocess.run(args, cwd=str(repo_path), text=True, capture_output=True, check=False)
+    if proc.returncode != 0:
+        raise ToolError(
+            "WORKTREE_CLEANUP_FAILED",
+            "Failed to remove git worktree.",
+            {"worktree_path": str(worktree_path), "stderr": proc.stderr},
+        )
+    return {"removed": True, "path": str(worktree_path), "dirty": dirty}
+def _is_agentpool_worktree(entry: dict[str, str | bool]) -> bool:
+    path = str(entry.get("path") or "")
+    branch = str(entry.get("branch") or "")
+    return ".agentpool-worktrees" in path or branch.startswith("refs/heads/agentpool/")

agentpool/mcp/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ """MCP surface for AgentPool."""

agentpool/mcp/resources.py ADDED Viewed

@@ -0,0 +1,64 @@
+from __future__ import annotations
+from importlib import resources
+import json
+from pathlib import Path
+from typing import Any
+from agentpool.agent_io import compact_artifact_manifest, lockdown_resource, omitted_worker_output, wrap_untrusted
+from agentpool.session_manager import SessionManager
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+def read_resource(manager: SessionManager, uri: str, lockdown: bool = False) -> str:
+    if uri == "agentpool://quickstart":
+        return _text_resource("agentpool-skill.md")
+    if uri == "agentpool://onboarding":
+        return _text_resource("onboarding.md")
+    if uri == "agentpool://skill.md":
+        return _text_resource("agentpool-skill.md")
+    prefix = "agentpool://sessions/"
+    if uri.startswith(prefix):
+        tail = uri[len(prefix) :]
+        parts = tail.split("/")
+        session_id = parts[0]
+        session = manager._require_session(session_id)
+        if len(parts) == 1:
+            return session.model_dump_json(indent=2)
+        if parts[1] == "transcript":
+            if lockdown:
+                return _json(lockdown_resource(session.transcript_path, "transcript"))
+            return _json(_worker_text_resource(session.id, "transcript", session.transcript_path))
+        if parts[1] == "events":
+            if lockdown:
+                return _json(lockdown_resource(session.events_path, "events"))
+            return _json(_worker_text_resource(session.id, "events", session.events_path))
+    artifact_prefix = "agentpool://artifacts/"
+    if uri.startswith(artifact_prefix):
+        session_id = uri[len(artifact_prefix) :]
+        return _json(compact_artifact_manifest(manager.artifact_manifest(session_id), lockdown=lockdown))
+    raise KeyError(f"Unknown AgentPool resource URI: {uri}")
+def _json(data: Any) -> str:
+    return json.dumps(data, indent=2, default=str)
+def _text_resource(filename: str) -> str:
+    packaged = resources.files("agentpool").joinpath("docs", filename)
+    if packaged.is_file():
+        return packaged.read_text(encoding="utf-8")
+    return (PROJECT_ROOT / "docs" / filename).read_text(encoding="utf-8")
+def _worker_text_resource(session_id: str, kind: str, path: str | Path) -> dict[str, Any]:
+    resolved = Path(path)
+    text = resolved.read_text(encoding="utf-8") if resolved.exists() else ""
+    return {
+        "session_id": session_id,
+        "kind": kind,
+        "path": str(resolved),
+        "exists": resolved.exists(),
+        "worker_output": wrap_untrusted(text, "full") if text else omitted_worker_output("full"),
+    }