agent-toolkit-cli 1.11.0__py3-none-win_amd64.whl

agent_toolkit/swarm/config.py

@@ -0,0 +1,351 @@
+"""Swarm config — precedence CLI > project > workspace > user > defaults."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+MODEL_PROFILE_NAMES = ("economy", "balanced", "quality", "private")
+TASK_CLASSES = ("planning", "coding", "review", "architecture", "hardening", "qa")
+
+
+# Aliases for prompt autodetect (short names -> OWNER/REPO)
+_PROMPT_ALIASES: dict[str, str] = {
+    "create-node-app": "Create-Node-App/create-node-app",
+    "cna-templates": "Create-Node-App/cna-templates",
+    "create-awesome-node-app": "Create-Node-App/create-node-app",
+}
+
+
+def _candidate_repo_paths(owner_repo: str) -> list[Path]:
+    owner, repo = owner_repo.split("/", 1)
+    candidates: list[Path] = []
+    ws = Path.home() / ".ai-workspace"
+    candidates.append(ws / "repos" / "github.com" / owner / repo)
+    candidates.append(ws / "repos" / owner / repo)
+    try:
+        cwd_ws = Path.cwd().resolve()
+        for parent in [cwd_ws] + list(cwd_ws.parents):
+            if (parent / "repos").is_dir() and parent.name == ".ai-workspace":
+                candidates.append(parent / "repos" / "github.com" / owner / repo)
+                candidates.append(parent / "repos" / owner / repo)
+                break
+    except Exception:
+        pass
+    candidates.append(Path.home() / ".ai-workspace" / "repos" / "github.com" / owner / repo)
+    candidates.append(Path.cwd() / repo)
+    return candidates
+
+
+def _resolve_owner_repo_from_prompt(prompt: str | None) -> str | None:
+    if not prompt:
+        return None
+    import re
+
+    m = re.search(r"https?://github\.com/([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)", prompt)
+    if m:
+        return f"{m.group(1)}/{m.group(2)}"
+    m = re.search(r"\b([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)(?:#\d+)?\b", prompt)
+    if m:
+        candidate = f"{m.group(1)}/{m.group(2)}"
+        if "/" in candidate and not candidate.lower().startswith("error"):
+            for cand in _candidate_repo_paths(candidate):
+                if (cand / ".git").exists():
+                    return candidate
+            if candidate.startswith("Create-Node-App/"):
+                return candidate
+            pass
+    low = prompt.lower()
+    for alias, owner_repo in _PROMPT_ALIASES.items():
+        if alias in low:
+            return owner_repo
+    return None
+
+
+def autodetect_repo_from_prompt(prompt: str | None) -> Path | None:
+    owner_repo = _resolve_owner_repo_from_prompt(prompt)
+    if not owner_repo:
+        return None
+    for cand in _candidate_repo_paths(owner_repo):
+        if (cand / ".git").exists():
+            return cand.resolve()
+    return None
+
+
+def find_repo_root(
+    start: Path | None = None, prompt_text: str | None = None, workspace: str | None = None
+) -> Path:
+    if workspace:
+        ws = Path(workspace).expanduser().resolve()
+        if (ws / ".git").exists():
+            return ws
+        if "/" in workspace and not workspace.startswith("/"):
+            for cand in _candidate_repo_paths(workspace):
+                if (cand / ".git").exists():
+                    return cand.resolve()
+        return ws
+    if prompt_text:
+        auto = autodetect_repo_from_prompt(prompt_text)
+        if auto is not None:
+            return auto
+    cur = (start or Path.cwd()).resolve()
+    # If we're inside a swarm worktree ( .../.agent-toolkit/swarm/runs/<run_id>/worktrees/<role> ),
+    # extract the main repo from that path directly
+    for p in [cur] + list(cur.parents):
+        # Detect being inside a run worktree: check for .agent-toolkit/swarm/runs segment
+        try:
+            parts = p.parts
+            if ".agent-toolkit" in parts:
+                idx = parts.index(".agent-toolkit")
+                # possible repo is parents[idx-1] if idx>0
+                if idx > 0:
+                    candidate = Path(*parts[:idx])
+                    if (candidate / ".git").exists() and (candidate / ".git").is_dir():
+                        return candidate.resolve()
+                    # also check if candidate is inside worktree path, try to find real repo via git common dir
+                    if candidate.exists():
+                        # Try git common dir resolution
+                        import subprocess
+
+                        try:
+                            res = subprocess.run(
+                                ["git", "rev-parse", "--git-common-dir"],
+                                cwd=str(p),
+                                capture_output=True,
+                                text=True,
+                                timeout=3,
+                            )
+                            if res.returncode == 0:
+                                common = res.stdout.strip()
+                                # common is like /path/to/repo/.git or /path/to/repo/.git/worktrees/...
+                                # Find the repo root by looking for .git dir
+                                common_path = Path(common)
+                                if not common_path.is_absolute():
+                                    common_path = (p / common_path).resolve()
+                                # common_path is .git or .git/worktrees/...
+                                # The repo root is parent of .git
+                                if common_path.name == ".git":
+                                    return common_path.parent.resolve()
+                                elif common_path.parent.name == ".git":
+                                    # e.g., .git/worktrees/...
+                                    return common_path.parent.parent.resolve()
+                                else:
+                                    # fallback: walk up from common_path looking for .git dir
+                                    for q in [common_path] + list(common_path.parents):
+                                        if (q / ".git").is_dir():
+                                            return q.resolve()
+                        except Exception:
+                            pass
+        except Exception:
+            pass
+    for p in [cur] + list(cur.parents):
+        git_path = p / ".git"
+        if git_path.exists():
+            # Prefer directory .git (main repo) over file (worktree)
+            if git_path.is_dir():
+                return p
+            # If .git is a file, it's a worktree — skip and continue searching up
+            # But also try to resolve via git common dir
+            try:
+                import subprocess
+
+                res = subprocess.run(
+                    ["git", "rev-parse", "--git-common-dir"],
+                    cwd=str(p),
+                    capture_output=True,
+                    text=True,
+                    timeout=2,
+                )
+                if res.returncode == 0:
+                    common = res.stdout.strip()
+                    cp = Path(common)
+                    if not cp.is_absolute():
+                        cp = (p / cp).resolve()
+                    if cp.name == ".git":
+                        return cp.parent.resolve()
+                    if cp.parent.name == ".git":
+                        return cp.parent.parent.resolve()
+            except Exception:
+                pass
+            # Continue to next parent instead of returning worktree
+            continue
+    return cur
+
+
+def find_run_dir_by_id(run_id: str, workspace: str | None = None) -> Path | None:
+    from .store import run_dir_for
+
+    if workspace:
+        repo = find_repo_root(workspace=workspace)
+        cand = run_dir_for(repo, run_id)
+        if cand.is_dir():
+            return cand
+        for cand2 in _candidate_repo_paths(workspace):
+            if (cand2 / ".git").exists():
+                cand = run_dir_for(cand2.resolve(), run_id)
+                if cand.is_dir():
+                    return cand
+    try:
+        repo = find_repo_root()
+        cand = run_dir_for(repo, run_id)
+        if cand.is_dir():
+            return cand
+    except Exception:
+        pass
+    search_roots = [
+        Path.home() / ".ai-workspace" / "repos" / "github.com",
+        Path.home() / ".ai-workspace" / "repos",
+    ]
+    try:
+        cwd = Path.cwd().resolve()
+        for parent in [cwd] + list(cwd.parents):
+            if (parent / "repos").is_dir() and parent.name == ".ai-workspace":
+                search_roots.append(parent / "repos" / "github.com")
+                search_roots.append(parent / "repos")
+                break
+    except Exception:
+        pass
+    for root in search_roots:
+        if not root.is_dir():
+            continue
+        try:
+            for owner in root.iterdir():
+                if not owner.is_dir():
+                    continue
+                if (owner / ".git").exists():
+                    cand = run_dir_for(owner, run_id)
+                    if cand.is_dir():
+                        return cand
+                else:
+                    for repo in owner.iterdir():
+                        if not repo.is_dir() or not (repo / ".git").exists():
+                            continue
+                        cand = run_dir_for(repo, run_id)
+                        if cand.is_dir():
+                            return cand
+        except Exception:
+            continue
+    home_cand = Path.home() / ".agent-toolkit" / "swarm" / "runs" / run_id
+    if home_cand.is_dir():
+        return home_cand
+    return None
+
+
+def list_all_runs(workspace: str | None = None) -> list[Path]:
+    from .store import list_runs
+
+    if workspace:
+        repo = find_repo_root(workspace=workspace)
+        return list_runs(repo)
+    try:
+        repo = find_repo_root()
+        runs = list_runs(repo)
+        if runs:
+            return runs
+        if repo.name == ".ai-workspace" or (repo / "repos").is_dir():
+            all_runs: list[Path] = []
+            seen: set[Path] = set()
+            search_roots = [
+                Path.home() / ".ai-workspace" / "repos" / "github.com",
+                Path.home() / ".ai-workspace" / "repos",
+            ]
+            for parent in [repo] + list(repo.parents):
+                if (parent / "repos").is_dir() and parent.name == ".ai-workspace":
+                    search_roots.append(parent / "repos" / "github.com")
+                    break
+            for root in search_roots:
+                if not root.is_dir():
+                    continue
+                for owner in root.iterdir():
+                    if not owner.is_dir():
+                        continue
+                    for maybe_repo in (
+                        [owner]
+                        if (owner / ".git").exists()
+                        else (list(owner.iterdir()) if owner.is_dir() else [])
+                    ):
+                        if not maybe_repo.is_dir() or not (maybe_repo / ".git").exists():
+                            continue
+                        for rd in list_runs(maybe_repo):
+                            rp = rd.resolve()
+                            if rp not in seen:
+                                seen.add(rp)
+                                all_runs.append(rd)
+            home_root = Path.home() / ".agent-toolkit" / "swarm" / "runs"
+            if home_root.is_dir():
+                for rd in home_root.iterdir():
+                    if rd.is_dir():
+                        rp = rd.resolve()
+                        if rp not in seen:
+                            seen.add(rp)
+                            all_runs.append(rd)
+            return sorted(
+                all_runs, key=lambda p: p.stat().st_mtime if p.exists() else 0, reverse=True
+            )
+    except Exception:
+        pass
+    return []
+
+
+def load_yaml_file(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    text = path.read_text(encoding="utf-8")
+    try:
+        import yaml  # type: ignore
+
+        data = yaml.safe_load(text)
+        return data if isinstance(data, dict) else {}
+    except ImportError:
+        import json
+
+        try:
+            return json.loads(text)
+        except Exception:
+            return {}
+    except Exception:
+        return {}
+
+
+def resolve_config(repo_root: Path, cli_overrides: dict[str, Any] | None = None) -> dict[str, Any]:
+    # Precedence: CLI > project-local > workspace > user > defaults
+    defaults = {
+        "recipe": "pair",
+        "ui": "auto",
+        "runner": "opencode",
+        "model_profile": "balanced",
+        "budget": {},
+        "model_profiles": {},
+    }
+    # User config
+    user_cfg_path = Path.home() / ".config" / "agent-toolkit" / "swarm.yaml"
+    user_cfg = load_yaml_file(user_cfg_path)
+    # Workspace: repo/.agent-toolkit/swarm.yaml OR swarm.yaml
+    ws_cfg = {}
+    for p in [
+        repo_root / ".agent-toolkit" / "swarm.yaml",
+        repo_root / "swarm.yaml",
+        repo_root / ".agent-toolkit" / "swarm" / "config.yaml",
+    ]:
+        if p.is_file():
+            ws_cfg = load_yaml_file(p)
+            break
+    # Project-local is same as workspace for now (repo root)
+    merged = dict(defaults)
+    for src in (user_cfg, ws_cfg):
+        if src:
+            for k, v in src.items():
+                if v is not None:
+                    if isinstance(v, dict) and isinstance(merged.get(k), dict):
+                        merged[k] = {**merged[k], **v}
+                    else:
+                        merged[k] = v
+    if cli_overrides:
+        for k, v in cli_overrides.items():
+            if v is not None:
+                merged[k] = v
+    # Env overrides for runtime paths (not primary config)
+    if os.environ.get("AGENT_TOOLKIT_SWARM_RUNS_DIR"):
+        merged["runs_dir"] = os.environ["AGENT_TOOLKIT_SWARM_RUNS_DIR"]
+    return merged

agent_toolkit/swarm/handoff.py

@@ -0,0 +1,174 @@
+"""Handoff protocol — durable filesystem queue with validation."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from .models import HANDOFF_VERSION
+from .store import now_ts, validate_artifact_path
+
+ALLOWED_TYPES = {"artifact", "commit", "feedback", "decision_request"}
+SHA_RE = re.compile(r"^[0-9a-f]{40}$")
+ROLE_RE = re.compile(r"^[a-z][a-z0-9_-]{1,31}$")
+
+
+def handoff_id_for(payload: dict[str, Any]) -> str:
+    raw = json.dumps(payload, sort_keys=True)
+    return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+def validate_handoff(data: dict[str, Any], run_dir: Path, roles: set[str]) -> list[str]:
+    errors: list[str] = []
+    if data.get("version") != HANDOFF_VERSION:
+        errors.append(f"version must be {HANDOFF_VERSION}")
+    htype = data.get("type")
+    if htype not in ALLOWED_TYPES:
+        errors.append(f"type must be one of {ALLOWED_TYPES}, got {htype!r}")
+    frm = data.get("from")
+    to = data.get("to")
+    if not isinstance(frm, str) or not ROLE_RE.match(frm):
+        errors.append(f"from invalid: {frm!r}")
+    elif frm not in roles and frm != "human":
+        errors.append(f"unknown from role: {frm!r}")
+    if not isinstance(to, str) or (not ROLE_RE.match(to) and to != "human"):
+        errors.append(f"to invalid: {to!r}")
+    elif to not in roles and to != "human":
+        errors.append(f"unknown to role: {to!r}")
+    prio = data.get("priority")
+    if not isinstance(prio, int) or not (0 <= prio <= 100):
+        errors.append("priority must be int 0..100")
+    artifact = data.get("artifact")
+    if artifact is not None:
+        if not isinstance(artifact, str):
+            errors.append("artifact must be string")
+        else:
+            try:
+                validate_artifact_path(run_dir, artifact)
+                # ensure stays under run_dir, no traversal — already checked
+                if artifact.startswith("/") or ".." in artifact:
+                    errors.append("artifact traversal")
+            except ValueError as e:
+                errors.append(str(e))
+            # size limit check (1 MB default artifact limit later)
+            if artifact and len(artifact) > 512:
+                errors.append("artifact path too long")
+    if htype == "commit":
+        commit = data.get("commit")
+        branch = data.get("branch")
+        if not isinstance(commit, str) or not SHA_RE.match(commit.lower()):
+            errors.append("commit must be 40 hex chars")
+        if not isinstance(branch, str) or not branch:
+            errors.append("branch required for commit handoff")
+        elif ".." in branch or branch.startswith("/"):
+            errors.append("branch traversal")
+    # blocking check for feedback
+    if htype == "feedback":
+        if "blocking" in data and not isinstance(data["blocking"], bool):
+            errors.append("blocking must be bool")
+    return errors
+
+
+def write_handoff_outbox(run_dir: Path, data: dict[str, Any]) -> Path:
+    # Atomically write to handoffs/outbox/<id>.json — ensure unique ID if collision
+    hid = data.get("handoff_id") or handoff_id_for(data)
+    data = dict(data)
+    data["handoff_id"] = hid
+    data["created_at"] = now_ts()
+    data.setdefault("version", HANDOFF_VERSION)
+    outbox = run_dir / "handoffs" / "outbox"
+    outbox.mkdir(parents=True, exist_ok=True)
+    # Ensure unique hid if file exists in any state
+    tried = 0
+    while any(
+        (run_dir / "handoffs" / st / f"{hid}.json").exists()
+        for st in ["outbox", "queued", "active", "completed", "failed"]
+    ):
+        # Append random suffix
+        import secrets
+
+        hid = handoff_id_for(data) + secrets.token_hex(2)
+        data["handoff_id"] = hid
+        tried += 1
+        if tried > 5:
+            break
+    tmp_fd, tmp_path = tempfile.mkstemp(dir=str(outbox), prefix=".tmp-")
+    try:
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, sort_keys=True)
+        dest = outbox / f"{hid}.json"
+        os.replace(tmp_path, dest)
+        return dest
+    finally:
+        try:
+            Path(tmp_path).unlink(missing_ok=True)
+        except Exception:
+            pass
+
+
+def move_handoff(run_dir: Path, handoff_id: str, from_state: str, to_state: str) -> Path | None:
+    src = run_dir / "handoffs" / from_state / f"{handoff_id}.json"
+    dst = run_dir / "handoffs" / to_state / f"{handoff_id}.json"
+    if not src.is_file():
+        return None
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    src.rename(dst)
+    return dst
+
+
+def list_handoffs(run_dir: Path, state: str) -> list[dict[str, Any]]:
+    d = run_dir / "handoffs" / state
+    if not d.is_dir():
+        return []
+    items: list[dict[str, Any]] = []
+    for p in sorted(d.glob("*.json")):
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+            items.append(data)
+        except Exception:
+            continue
+    return items
+
+
+def validate_commit_exists(repo_root: Path, sha: str) -> bool:
+    import subprocess
+
+    try:
+        res = subprocess.run(
+            ["git", "cat-file", "-t", sha],
+            cwd=str(repo_root),
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return res.returncode == 0 and "commit" in res.stdout
+    except Exception:
+        return False
+
+
+def resolve_sha(repo_root: Path, abbrev: str) -> str | None:
+    import subprocess
+
+    # Use git rev-parse to resolve ambiguous abbreviations
+    try:
+        res = subprocess.run(
+            ["git", "rev-parse", "--verify", abbrev + "^{commit}"],
+            cwd=str(repo_root),
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if res.returncode != 0:
+            return None
+        sha = res.stdout.strip()
+        if SHA_RE.match(sha):
+            # Check ambiguous: rev-parse should fail if ambiguous, but verify
+            return sha
+        return None
+    except Exception:
+        return None