@team-agent/installer 0.2.11 → 0.3.0

package/src/team_agent/restart/snapshot.py

@@ -1,70 +0,0 @@
-from __future__ import annotations
-
-import copy
-import json
-import os
-import re
-import shutil
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from team_agent.paths import runtime_dir
-from team_agent.spec import load_spec
-from team_agent.state import normalize_agent_session_state
-
-
-def save_team_runtime_snapshot(workspace: Path, state: dict[str, Any]) -> Path | None:
-    from team_agent.runtime import _spec_team_dir
-    session_name = state.get("session_name")
-    if not session_name:
-        return None
-    snapshot_dir = team_runtime_snapshot_dir(workspace, str(session_name))
-    snapshot_dir.mkdir(parents=True, exist_ok=True)
-    snapshot_state = copy.deepcopy(state)
-    spec_path = Path(str(state.get("spec_path") or ""))
-    if spec_path.is_file():
-        if not snapshot_state.get("team_dir"):
-            snapshot_state["team_dir"] = str(_spec_team_dir(spec_path, workspace))
-        snapshot_spec = snapshot_dir / "team.spec.yaml"
-        if spec_path.resolve() != snapshot_spec.resolve():
-            shutil.copy2(spec_path, snapshot_spec)
-        snapshot_state["spec_path"] = str(snapshot_spec)
-    snapshot_state["team_snapshot"] = {
-        "session_name": session_name,
-        "team_name": state_team_name(snapshot_state),
-        "snapshot_dir": str(snapshot_dir),
-        "updated_at": datetime.now(timezone.utc).isoformat(),
-    }
-    state_path = snapshot_dir / "state.json"
-    tmp_path = state_path.with_suffix(".json.tmp")
-    tmp_path.write_text(json.dumps(snapshot_state, indent=2, ensure_ascii=False), encoding="utf-8")
-    os.replace(tmp_path, state_path)
-    return state_path
-
-
-def team_runtime_snapshot_dir(workspace: Path, session_name: str) -> Path:
-    return runtime_dir(workspace) / "teams" / safe_snapshot_name(session_name)
-
-
-def safe_snapshot_name(value: str) -> str:
-    return re.sub(r"[^A-Za-z0-9_.-]", "_", value).strip("._-") or "team"
-
-
-def state_team_name(state: dict[str, Any]) -> str | None:
-    spec_path = state.get("spec_path")
-    if not spec_path:
-        return None
-    try:
-        return str(load_spec(Path(str(spec_path))).get("team", {}).get("name") or "")
-    except Exception:
-        return None
-
-
-def load_snapshot_state(path: Path) -> dict[str, Any] | None:
-    try:
-        state = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-    normalize_agent_session_state(state)
-    return state

package/src/team_agent/routing.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import fnmatch
-import re
-from typing import Any
-
-
-def route_task(spec: dict[str, Any], task: dict[str, Any]) -> dict[str, Any]:
-    leader_id = spec.get("leader", {}).get("id", "leader")
-    valid_agents = {leader_id, *(a["id"] for a in spec.get("agents", []))}
-    explicit = task.get("assignee")
-    if explicit:
-        if explicit in valid_agents:
-            return {"agent_id": explicit, "reason": "explicit assignee on task"}
-        return {"agent_id": leader_id, "reason": f"unknown explicit assignee {explicit!r}"}
-
-    rules = sorted(
-        spec.get("routing", {}).get("rules", []),
-        key=lambda rule: rule.get("priority", 0),
-        reverse=True,
-    )
-    for rule in rules:
-        if _rule_matches(rule, task):
-            return {
-                "agent_id": rule["assign_to"],
-                "reason": f"matched routing rule {rule.get('id', '<unnamed>')}",
-            }
-
-    default = spec.get("routing", {}).get("default_assignee", leader_id)
-    return {"agent_id": default, "reason": "no routing rule matched"}
-
-
-def _rule_matches(rule: dict[str, Any], task: dict[str, Any]) -> bool:
-    match = rule.get("match")
-    if isinstance(match, dict) and not _structured_match(match, task):
-        return False
-    when = rule.get("when")
-    if when and not _when_match(str(when), task):
-        return False
-    return True
-
-
-def _structured_match(match: dict[str, Any], task: dict[str, Any]) -> bool:
-    if "type" in match and task.get("type") not in _as_list(match["type"]):
-        return False
-    if "risk" in match and task.get("risk") not in _as_list(match["risk"]):
-        return False
-    if "requires_tools" in match:
-        required = set(_as_list(match["requires_tools"]))
-        actual = set(task.get("requires_tools", []))
-        if not required.issubset(actual):
-            return False
-    if "files" in match:
-        patterns = _as_list(match["files"])
-        files = task.get("files", [])
-        if not any(fnmatch.fnmatch(path, pattern) for path in files for pattern in patterns):
-            return False
-    return True
-
-
-def _when_match(expr: str, task: dict[str, Any]) -> bool:
-    type_match = re.fullmatch(r"task\.type\s+in\s+\[(.*)\]", expr.strip())
-    if type_match:
-        values = _quoted_values(type_match.group(1))
-        return task.get("type") in values
-
-    eq_match = re.fullmatch(r"task\.(type|risk)\s*==\s*['\"]([^'\"]+)['\"]", expr.strip())
-    if eq_match:
-        return task.get(eq_match.group(1)) == eq_match.group(2)
-
-    files_match = re.fullmatch(r"task\.files\s+matches\s+\[(.*)\]", expr.strip())
-    if files_match:
-        patterns = _quoted_values(files_match.group(1))
-        return any(fnmatch.fnmatch(path, pattern) for path in task.get("files", []) for pattern in patterns)
-
-    return False
-
-
-def _quoted_values(raw: str) -> list[str]:
-    return re.findall(r"['\"]([^'\"]+)['\"]", raw)
-
-
-def _as_list(value: Any) -> list[Any]:
-    return value if isinstance(value, list) else [value]