@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/providers.py

@@ -1,163 +0,0 @@
-from __future__ import annotations
-
-import os
-import shlex
-from pathlib import Path
-from typing import Any
-
-from team_agent.paths import repo_root
-from team_agent.profiles import ensure_compatible_claude_mcp_config, prepare_agent_profile_launch
-from team_agent.provider_cli.adapter import (
-    ProviderAdapter,
-    ResumeUnavailable,
-    agent_model,
-    parse_time,
-    read_json_object,
-)
-from team_agent.provider_cli.claude import ClaudeCodeAdapter
-from team_agent.provider_cli.codex import CodexAdapter
-from team_agent.provider_cli.fake import FakeAdapter
-from team_agent.provider_cli.gemini import GeminiCliAdapter
-from team_agent.provider_cli.prompt import TEAMMATE_SYSTEM_PROMPT, compile_system_prompt
-
-# Import-time assertions: every re-exported symbol must resolve at import,
-# so a refactor that drops one of these provider_cli APIs fails loudly here
-# instead of silently breaking callers that still import from providers.
-assert issubclass(ClaudeCodeAdapter, ProviderAdapter)
-assert issubclass(CodexAdapter, ProviderAdapter)
-assert issubclass(GeminiCliAdapter, ProviderAdapter)
-assert issubclass(FakeAdapter, ProviderAdapter)
-assert callable(compile_system_prompt)
-assert isinstance(TEAMMATE_SYSTEM_PROMPT, str)
-assert callable(agent_model)
-assert callable(parse_time)
-assert callable(read_json_object)
-assert issubclass(ResumeUnavailable, RuntimeError)
-
-
-ADAPTERS: dict[str, ProviderAdapter] = {
-    "claude": ClaudeCodeAdapter(),
-    "claude_code": ClaudeCodeAdapter(),
-    "codex": CodexAdapter(),
-    "gemini_cli": GeminiCliAdapter(),
-    "fake": FakeAdapter(),
-}
-
-
-def get_adapter(provider: str) -> ProviderAdapter:
-    try:
-        return ADAPTERS[provider]
-    except KeyError as exc:
-        raise KeyError(f"Unsupported provider: {provider}") from exc
-
-
-def shell_command_for_agent(agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> str:
-    adapter = get_adapter(agent["provider"])
-    command_agent = dict(agent)
-    profile_launch = command_agent.get("_provider_profile") or prepare_agent_profile_launch(workspace, command_agent)
-    if profile_launch:
-        command_agent["_provider_profile"] = profile_launch
-        agent["_provider_profile"] = profile_launch
-    if (
-        agent.get("provider") in {"claude", "claude_code"}
-        and profile_launch
-        and profile_launch.get("auth_mode") == "compatible_api"
-        and profile_launch.get("claude_projects_root")
-    ):
-        ensure_compatible_claude_mcp_config(workspace, agent["id"], mcp_config)
-    cmd = adapter.build_command(command_agent, workspace, mcp_config)
-    if command_agent.get("_session_id"):
-        agent["_session_id"] = command_agent["_session_id"]
-    return shell_command(cmd, agent["id"], workspace, profile_launch)
-
-
-def shell_resume_command_for_agent(
-    agent: dict[str, Any],
-    agent_state: dict[str, Any],
-    workspace: Path,
-    mcp_config: dict[str, Any],
-) -> str:
-    adapter = get_adapter(agent["provider"])
-    command_agent = dict(agent)
-    profile_launch = command_agent.get("_provider_profile") or prepare_agent_profile_launch(workspace, command_agent)
-    if profile_launch:
-        command_agent["_provider_profile"] = profile_launch
-        agent["_provider_profile"] = profile_launch
-    if (
-        agent.get("provider") in {"claude", "claude_code"}
-        and profile_launch
-        and profile_launch.get("auth_mode") == "compatible_api"
-        and profile_launch.get("claude_projects_root")
-    ):
-        ensure_compatible_claude_mcp_config(workspace, agent["id"], mcp_config)
-    resume_state = dict(agent_state)
-    resume_state["_agent_spec"] = command_agent
-    cmd = adapter.build_resume_command(resume_state, workspace, mcp_config)
-    return shell_command(cmd, agent["id"], workspace, profile_launch)
-
-
-def shell_fork_command_for_agent(
-    agent: dict[str, Any],
-    source_session_id: str,
-    workspace: Path,
-    mcp_config: dict[str, Any],
-) -> str:
-    adapter = get_adapter(agent["provider"])
-    command_agent = dict(agent)
-    profile_launch = command_agent.get("_provider_profile") or prepare_agent_profile_launch(workspace, command_agent)
-    if profile_launch:
-        command_agent["_provider_profile"] = profile_launch
-        agent["_provider_profile"] = profile_launch
-    if (
-        agent.get("provider") in {"claude", "claude_code"}
-        and profile_launch
-        and profile_launch.get("auth_mode") == "compatible_api"
-        and profile_launch.get("claude_projects_root")
-    ):
-        ensure_compatible_claude_mcp_config(workspace, agent["id"], mcp_config)
-    cmd = adapter.build_fork_command(command_agent, source_session_id, workspace, mcp_config)
-    if command_agent.get("_session_id"):
-        agent["_session_id"] = command_agent["_session_id"]
-    return shell_command(cmd, agent["id"], workspace, profile_launch)
-
-
-def shell_command(
-    cmd: list[str],
-    agent_id: str,
-    workspace: Path,
-    profile_launch: dict[str, Any] | None = None,
-) -> str:
-    env = {
-        "TEAM_AGENT_ID": agent_id,
-        "TEAM_AGENT_WORKSPACE": str(workspace),
-        "PYTHONPATH": str(repo_root() / "src"),
-    }
-    if os.environ.get("PATH"):
-        # tmux commands inherit the tmux server's old environment, not the
-        # current Codex shell. Preserve PATH so local wrappers such as
-        # ~/.local/bin/codex remain effective without logging proxy secrets.
-        env["PATH"] = os.environ["PATH"]
-    exports = " ".join(f"{key}={shlex.quote(value)}" for key, value in env.items())
-    source_profile = ""
-    env_file = profile_launch.get("env_file") if profile_launch else None
-    if env_file:
-        source_profile = f". {shlex.quote(str(env_file))} && "
-    return f"cd {shlex.quote(str(workspace))} && export {exports} && {source_profile}exec {shlex.join(cmd)}"
-
-
-__all__ = [
-    "ADAPTERS",
-    "ClaudeCodeAdapter",
-    "CodexAdapter",
-    "FakeAdapter",
-    "GeminiCliAdapter",
-    "ProviderAdapter",
-    "ResumeUnavailable",
-    "TEAMMATE_SYSTEM_PROMPT",
-    "compile_system_prompt",
-    "get_adapter",
-    "shell_command",
-    "shell_command_for_agent",
-    "shell_fork_command_for_agent",
-    "shell_resume_command_for_agent",
-]

package/src/team_agent/quality_gates.py

@@ -1,104 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Iterable
-
-
-@dataclass(frozen=True)
-class LineCountResult:
-    path: str
-    lines: int
-    allowed: bool
-    reason: str | None = None
-
-
-ALLOWLIST_KEYS = {"approved_exceptions", "temporary_debt"}
-
-
-def parse_line_count_allowlist_payload(payload: object, *, source: str = "line-count allowlist") -> dict[str, dict[str, Any]]:
-    if not isinstance(payload, dict):
-        raise ValueError(f"{source}: line-count allowlist must be a JSON object")
-    unexpected = sorted(set(payload) - ALLOWLIST_KEYS)
-    if unexpected:
-        keys = ", ".join(unexpected)
-        expected = ", ".join(sorted(ALLOWLIST_KEYS))
-        raise ValueError(f"{source}: unexpected top-level key(s): {keys}; expected new schema keys: {expected}")
-    approved = payload.get("approved_exceptions", {})
-    temporary = payload.get("temporary_debt", {})
-    if not isinstance(approved, dict):
-        raise ValueError(f"{source}: approved_exceptions must be an object")
-    if not isinstance(temporary, dict):
-        raise ValueError(f"{source}: temporary_debt must be an object")
-    for file_path, entry in approved.items():
-        if not isinstance(entry, dict):
-            raise ValueError(f"{source}: approved exception for {file_path} must be an object")
-        max_lines = entry.get("max_lines")
-        if not isinstance(max_lines, int) or max_lines < 1:
-            raise ValueError(f"{source}: approved exception for {file_path} must declare positive integer max_lines")
-    return {"approved_exceptions": approved, "temporary_debt": temporary}
-
-
-def load_line_count_allowlist(path: Path) -> dict[str, dict[str, Any]]:
-    text = path.read_text(encoding="utf-8").strip()
-    if not text:
-        return {"approved_exceptions": {}, "temporary_debt": {}}
-    try:
-        data = json.loads(text)
-    except json.JSONDecodeError as exc:
-        raise ValueError(f"{path}: invalid JSON in line-count allowlist: {exc}") from exc
-    return parse_line_count_allowlist_payload(data, source=str(path))
-
-
-def check_python_file_line_counts(
-    root: Path,
-    *,
-    allowlist_path: Path,
-    include_roots: Iterable[str] = ("src/team_agent", "tests"),
-    max_lines: int = 500,
-) -> list[LineCountResult]:
-    allowlist = load_line_count_allowlist(allowlist_path)
-    approved = allowlist["approved_exceptions"]
-    results: list[LineCountResult] = []
-    for relative_path in _iter_python_files(root, include_roots):
-        full_path = root / relative_path
-        line_count = _line_count(full_path)
-        entry = approved.get(relative_path)
-        if line_count <= max_lines:
-            results.append(LineCountResult(relative_path, line_count, allowed=True))
-            continue
-        if entry:
-            allowed_max = int(entry["max_lines"])
-            results.append(
-                LineCountResult(
-                    relative_path,
-                    line_count,
-                    allowed=line_count <= allowed_max,
-                    reason=str(entry.get("reason") or ""),
-                )
-            )
-            continue
-        results.append(LineCountResult(relative_path, line_count, allowed=False))
-    return results
-
-
-def line_count_failures(results: Iterable[LineCountResult]) -> list[LineCountResult]:
-    return [result for result in results if not result.allowed]
-
-
-def _iter_python_files(root: Path, include_roots: Iterable[str]) -> list[str]:
-    paths: list[str] = []
-    for include_root in include_roots:
-        base = root / include_root
-        if not base.exists():
-            continue
-        for path in base.rglob("*.py"):
-            if "__pycache__" in path.parts:
-                continue
-            paths.append(path.relative_to(root).as_posix())
-    return sorted(paths)
-
-
-def _line_count(path: Path) -> int:
-    return len(path.read_text(encoding="utf-8").splitlines())

package/src/team_agent/restart/__init__.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from team_agent.restart.orchestration import restart, rollback_restart_session
-from team_agent.restart.selection import (
-    format_restart_candidates,
-    quick_start_existing_context,
-    restart_candidate_from_state,
-    restart_candidates,
-    select_restart_state,
-    state_has_restart_context,
-)
-from team_agent.restart.snapshot import (
-    load_snapshot_state,
-    safe_snapshot_name,
-    save_team_runtime_snapshot,
-    state_team_name,
-    team_runtime_snapshot_dir,
-)
-
-__all__ = [
-    "format_restart_candidates",
-    "load_snapshot_state",
-    "quick_start_existing_context",
-    "restart",
-    "restart_candidate_from_state",
-    "restart_candidates",
-    "rollback_restart_session",
-    "safe_snapshot_name",
-    "save_team_runtime_snapshot",
-    "select_restart_state",
-    "state_has_restart_context",
-    "state_team_name",
-    "team_runtime_snapshot_dir",
-]