ags-cli 0.1.0__py3-none-any.whl

harness/orchestrator/handoff.py

@@ -0,0 +1,33 @@
+"""Deterministic handoff block injected when a session switches provider."""
+from __future__ import annotations
+
+import re
+
+_WRITE_TOOLS = ("write_file", "replace_in_file")
+_TOOL_RE = re.compile(r"ran tool '([^']+)' with .*?'path': '([^']+)'")
+_MAX_RECENT = 12
+
+
+def files_touched_from_blocks(blocks: list[str]) -> list[str]:
+    seen: dict[str, None] = {}
+    for b in blocks:
+        m = _TOOL_RE.search(b)
+        if m and m.group(1) in _WRITE_TOOLS:
+            seen.setdefault(m.group(2))
+    return list(seen)
+
+
+def build_handoff_block(
+    *, from_provider: str, summary: str,
+    recent_blocks: list[str], files_touched: list[str],
+) -> str:
+    parts = [f"## Handoff from {from_provider}",
+             "You are taking over an in-progress task from another agent."]
+    if summary:
+        parts += ["", "### Task state", summary]
+    if files_touched:
+        parts += ["", "### Files modified so far", *[f"- {f}" for f in files_touched]]
+    if recent_blocks:
+        parts += ["", "### Most recent turns", *recent_blocks[-_MAX_RECENT:]]
+    parts += ["", "Continue the task; do not restart work that is already done."]
+    return "\n".join(parts)

harness/orchestrator/lifecycle.py

@@ -0,0 +1,69 @@
+"""Run lifecycle helpers: retries with backoff, timeouts, and cancellation flags.
+
+Cancellation is cooperative: the worker checks ``is_cancelled(run_id)`` between
+events using a process-local set (API and executor share one process)."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+async def run_with_timeout(coro: Awaitable[T], timeout_s: float) -> T:
+    return await asyncio.wait_for(coro, timeout=timeout_s)
+
+
+async def retry_async(
+    fn: Callable[[], Awaitable[T]],
+    *,
+    attempts: int = 3,
+    base_delay: float = 0.5,
+    max_delay: float = 8.0,
+    retriable: tuple[type[BaseException], ...] = (Exception,),
+) -> T:
+    last: BaseException | None = None
+    for i in range(attempts):
+        try:
+            return await fn()
+        except retriable as exc:  # noqa: PERF203
+            last = exc
+            if i == attempts - 1:
+                break
+            await asyncio.sleep(min(base_delay * (2**i), max_delay))
+    assert last is not None
+    raise last
+
+
+class InMemoryCancellationRegistry:
+    """Process-local cancellation for this daemonless setup. A module-level
+    singleton (``get_canceller``) makes the flag visible to both the cancel endpoint
+    and the in-process executor, which share one event loop."""
+
+    def __init__(self) -> None:
+        self._cancelled: set[str] = set()
+
+    async def request_cancel(self, run_id: str) -> None:
+        self._cancelled.add(run_id)
+
+    async def is_cancelled(self, run_id: str) -> bool:
+        return run_id in self._cancelled
+
+    async def clear(self, run_id: str) -> None:
+        self._cancelled.discard(run_id)
+
+    async def aclose(self) -> None:
+        return None
+
+
+_local_canceller: InMemoryCancellationRegistry | None = None
+
+
+def get_canceller():
+    """Cancellation registry: process-local in-memory store."""
+    global _local_canceller
+    if _local_canceller is None:
+        _local_canceller = InMemoryCancellationRegistry()
+    return _local_canceller

harness/orchestrator/native_resume.py

@@ -0,0 +1,93 @@
+"""Decide when a node should resume its provider's native session.
+
+Same-provider consecutive turns resume in place (the CLI keeps its own context,
+so the harness skips transcript re-injection). A provider switch starts a fresh
+native session and triggers a structured handoff block instead.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from harness.models.enums import AdapterKind
+
+# Providers whose native-resume flag is verified. Antigravity joins via the
+# capability probe (Task 12) or an explicit `params.native_sessions: true`.
+_DEFAULT_ON = {AdapterKind.claude_code}
+
+
+@dataclass(frozen=True)
+class ResumeDecision:
+    native_id: str | None
+    is_switch: bool
+
+
+def decide_resume(
+    *,
+    provider_name: str,
+    adapter_kind: AdapterKind,
+    native_sessions: dict,
+    last_provider: str | None,
+    params: dict,
+    probed_flags: set[str] | None = None,
+) -> ResumeDecision:
+    is_switch = last_provider is not None and last_provider != provider_name
+    native_id = (native_sessions or {}).get(provider_name)
+
+    # Determine whether native-resume is enabled for this adapter.
+    explicit = params.get("native_sessions")  # None if not set, True/False if set
+    if explicit is not None:
+        # Explicit params.native_sessions always wins (both ways).
+        enabled = bool(explicit)
+    elif adapter_kind == AdapterKind.antigravity:
+        # Antigravity: auto-enable when the CLI advertises --conversation, otherwise off.
+        # Explicit params.native_sessions overrides (handled above).
+        enabled = probed_flags is not None and "--conversation" in probed_flags
+    else:
+        # All other adapters: use the _DEFAULT_ON set.
+        enabled = adapter_kind in _DEFAULT_ON
+
+    if not enabled or is_switch or last_provider is None:
+        return ResumeDecision(native_id=None, is_switch=is_switch)
+    return ResumeDecision(native_id=native_id, is_switch=False)
+
+
+def context_meta_for(
+    *,
+    resume: ResumeDecision,
+    node_memory: str,
+    transcript_blocks: list[str],
+    window: int,
+) -> dict:
+    """Build the context_meta dict to persist on a Run row.
+
+    Encodes the resume mode decision and the key sizing stats that drove the
+    injected context for this node.  Purely a data-shape helper — no I/O.
+
+    Mode mapping:
+      native_id set → "native" (same-provider, resumed in place)
+      is_switch     → "handoff" (provider switch, structured handoff block)
+      else          → "replay" (first turn or non-resumable provider)
+    """
+    if resume.native_id is not None:
+        mode = "native"
+    elif resume.is_switch:
+        mode = "handoff"
+    else:
+        mode = "replay"
+
+    return {
+        "resume": mode,
+        "memory_chars": len(node_memory),
+        "transcript_blocks": len(transcript_blocks),
+        "window": window,
+    }
+
+
+def extract_native_id(events: list, adapter_kind: AdapterKind) -> str | None:
+    """Pull the provider-native session id out of a run's normalized events."""
+    for ev in events:
+        if getattr(ev, "type", None) == "adapter_meta":
+            nsid = (ev.data or {}).get("session_id") or (ev.data or {}).get("conversation_id")
+            if nsid:
+                return str(nsid)
+    return None

harness/orchestrator/policies.py

@@ -0,0 +1,101 @@
+"""Routing & execution policies.
+
+A policy compiles a task into a **run graph**: a set of ``RunNodeSpec`` nodes
+(each = one provider execution) with dependencies and a role. The engine executes
+independent nodes concurrently and respects dependencies. Policies are declared in
+``config.yaml`` under ``routing.policies`` and resolved here.
+
+Supported modes: single, fanout, fallback, judge_select, propose_merge,
+cheap_first_escalate, local_first_escalate.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from harness.models.enums import RoutingMode, RunRole
+
+
+@dataclass
+class RunNodeSpec:
+    node_id: str
+    provider: str
+    role: RunRole = RunRole.primary
+    depends_on: list[str] = field(default_factory=list)
+
+
+@dataclass
+class MergeSpec:
+    strategy: str = "merge"          # merge | judge | manual
+    by: str | None = None            # provider that performs the merge, if any
+    persist: bool = False            # persist merged result as workspace memory
+
+
+@dataclass
+class CompiledPolicy:
+    name: str
+    mode: RoutingMode
+    nodes: list[RunNodeSpec]
+    merge: MergeSpec | None = None
+    escalate_to: str | None = None
+
+
+def _role(value: str | None) -> RunRole:
+    try:
+        return RunRole(value) if value else RunRole.primary
+    except ValueError:
+        return RunRole.primary
+
+
+def compile_policy(
+    spec: dict,
+    *,
+    override_providers: list[str] | None = None,
+) -> CompiledPolicy:
+    """Compile a routing policy dict (from config) into a CompiledPolicy.
+
+    ``override_providers`` lets the CLI/API force a provider set for ``single`` /
+    ``fanout`` (e.g. ``run start --providers mock,local``)."""
+    name = spec.get("name", "single")
+    mode = RoutingMode(spec.get("mode", "single"))
+    merge = None
+    if (m := spec.get("merge")) is not None:
+        merge = MergeSpec(
+            strategy=m.get("strategy", "merge"),
+            by=m.get("by"),
+            persist=bool(m.get("persist", False)),
+        )
+
+    # Explicit node graph wins.
+    if spec.get("nodes"):
+        nodes = [
+            RunNodeSpec(
+                node_id=n.get("id") or f"{n['provider']}-{i}",
+                provider=n["provider"],
+                role=_role(n.get("role")),
+                depends_on=list(n.get("depends_on", [])),
+            )
+            for i, n in enumerate(spec["nodes"])
+        ]
+        return CompiledPolicy(name, mode, nodes, merge, spec.get("escalate_to"))
+
+    # Otherwise derive from mode + primary/override.
+    if override_providers:
+        providers = override_providers
+    elif mode in (RoutingMode.single, RoutingMode.local_first_escalate,
+                  RoutingMode.cheap_first_escalate, RoutingMode.fallback):
+        providers = [spec.get("primary", "local")]
+    else:
+        providers = [spec.get("primary", "local")]
+
+    nodes = [
+        RunNodeSpec(node_id=f"{p}-{i}", provider=p, role=RunRole.primary)
+        for i, p in enumerate(providers)
+    ]
+    return CompiledPolicy(name, mode, nodes, merge, spec.get("escalate_to"))
+
+
+def load_policy_specs(config: dict) -> dict[str, dict]:
+    """Index routing policy specs from config by name."""
+    policies = (config.get("routing") or {}).get("policies", [])
+    return {p["name"]: p for p in policies}

harness/orchestrator/reconcile.py

@@ -0,0 +1,39 @@
+"""Mark runs orphaned by a process crash/restart as failed, at startup."""
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from harness.models.enums import RunStatus, SessionStatus
+from harness.models.run import Run
+from harness.models.session import Session
+from harness.observability.logging import get_logger
+
+log = get_logger("reconcile")
+_ORPHAN = (RunStatus.queued, RunStatus.running, RunStatus.streaming)
+
+
+async def reconcile_interrupted(db: AsyncSession) -> int:
+    orphaned = (await db.execute(select(Run).where(Run.status.in_(_ORPHAN)))).scalars().all()
+    for r in orphaned:
+        r.status = RunStatus.failed
+        r.error = "interrupted by server restart"
+        r.finished_at = datetime.now(UTC)
+    await db.flush()
+
+    # Sessions parked waiting on a human approval are not orphaned — exclude
+    # them so a restart doesn't fail a run sitting in needs_approval.
+    parked_session_ids = (
+        await db.execute(
+            select(Run.session_id).where(Run.status == RunStatus.needs_approval).distinct()
+        )
+    ).scalars().all()
+    stmt = update(Session).where(Session.status == SessionStatus.running)
+    if parked_session_ids:
+        stmt = stmt.where(Session.id.notin_(parked_session_ids))
+    await db.execute(stmt.values(status=SessionStatus.failed))
+    if orphaned:
+        log.warning("reconciled_interrupted_runs", count=len(orphaned))
+    return len(orphaned)

harness/orchestrator/run_graph.py

@@ -0,0 +1,62 @@
+"""Run graph: a DAG over ``RunNodeSpec`` with topological-level scheduling.
+
+The engine asks the graph for successive "waves" of nodes whose dependencies are
+all satisfied, executing each wave concurrently. Cycles are rejected at build."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from harness.orchestrator.policies import RunNodeSpec
+
+
+@dataclass
+class RunGraph:
+    nodes: dict[str, RunNodeSpec]
+
+    @classmethod
+    def from_specs(cls, specs: list[RunNodeSpec]) -> RunGraph:
+        nodes = {s.node_id: s for s in specs}
+        # Validate dependencies exist and the graph is acyclic.
+        for s in specs:
+            for dep in s.depends_on:
+                if dep not in nodes:
+                    raise ValueError(f"node {s.node_id!r} depends on unknown {dep!r}")
+        graph = cls(nodes=nodes)
+        graph._assert_acyclic()
+        return graph
+
+    def _assert_acyclic(self) -> None:
+        WHITE, GRAY, BLACK = 0, 1, 2
+        color = dict.fromkeys(self.nodes, WHITE)
+
+        def visit(nid: str) -> None:
+            color[nid] = GRAY
+            for dep in self.nodes[nid].depends_on:
+                if color[dep] == GRAY:
+                    raise ValueError(f"cycle detected at {nid!r} -> {dep!r}")
+                if color[dep] == WHITE:
+                    visit(dep)
+            color[nid] = BLACK
+
+        for nid in self.nodes:
+            if color[nid] == WHITE:
+                visit(nid)
+
+    def waves(self) -> list[list[RunNodeSpec]]:
+        """Return execution waves: each inner list can run concurrently."""
+        remaining = dict(self.nodes)
+        done: set[str] = set()
+        result: list[list[RunNodeSpec]] = []
+        while remaining:
+            ready = [
+                s for s in remaining.values()
+                if all(dep in done for dep in s.depends_on)
+            ]
+            if not ready:  # pragma: no cover — guarded by _assert_acyclic
+                raise ValueError("deadlock: no ready nodes but graph non-empty")
+            result.append(ready)
+            for s in ready:
+                done.add(s.node_id)
+                del remaining[s.node_id]
+        return result

harness/orchestrator/snapshot.py

@@ -0,0 +1,49 @@
+"""Non-invasive git snapshot of a project tree before a write-mode run.
+
+Uses a throwaway index (GIT_INDEX_FILE) so the user's staging area and HEAD
+are never touched. Fails soft: any git error returns None."""
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+from harness.observability.logging import get_logger
+
+log = get_logger("snapshot")
+
+
+def _snapshot_sync(project_dir: str) -> str | None:
+    root = Path(project_dir)
+    if not (root / ".git").exists():
+        return None
+    with tempfile.NamedTemporaryFile(prefix="ags-idx-") as idx:
+        env = {**os.environ, "GIT_INDEX_FILE": idx.name}
+
+        def git(*args: str) -> str:
+            r = subprocess.run(["git", *args], shell=(os.name == "nt"), cwd=root, env=env,
+                               capture_output=True, text=True, timeout=60)
+            if r.returncode != 0:
+                raise RuntimeError(r.stderr.strip())
+            return r.stdout.strip()
+
+        try:
+            head = git("rev-parse", "--verify", "HEAD")
+        except RuntimeError:
+            head = None  # empty repo: snapshot with no parent
+        try:
+            if head:
+                git("read-tree", head)
+            git("add", "-A", ".")
+            tree = git("write-tree")
+            parent = ["-p", head] if head else []
+            return git("commit-tree", tree, *parent, "-m", "ags pre-run snapshot")
+        except (RuntimeError, subprocess.TimeoutExpired) as exc:
+            log.warning("git_snapshot_failed", error=str(exc))
+            return None
+
+
+async def git_snapshot(project_dir: str) -> str | None:
+    return await asyncio.to_thread(_snapshot_sync, project_dir)

harness/schemas/__init__.py

@@ -0,0 +1 @@
+"""Pydantic request/response DTOs (transport schemas) — decoupled from ORM models."""

harness/schemas/adapter.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import uuid
+
+from pydantic import BaseModel
+
+from harness.models.enums import AdapterKind
+
+
+class AdapterOut(BaseModel):
+    id: uuid.UUID
+    name: str
+    kind: AdapterKind
+    model: str | None = None
+    base_url: str | None = None
+    enabled: bool
+    capabilities: dict
+    managed: bool = False  # added via the GUI (overlay), so deletable from the GUI
+
+
+class AdapterTestResult(BaseModel):
+    name: str
+    kind: AdapterKind
+    ok: bool
+    latency_ms: float
+    detail: dict

harness/schemas/approval.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+from harness.models.enums import ApprovalActionClass, ApprovalStatus
+
+
+class ApprovalOut(BaseModel):
+    id: uuid.UUID
+    session_id: uuid.UUID
+    run_id: uuid.UUID | None = None
+    action_class: ApprovalActionClass
+    payload: dict
+    status: ApprovalStatus
+    decided_by: str | None = None
+    decided_at: datetime | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ApprovalDecideRequest(BaseModel):
+    decision: str  # "approved" or "denied"

harness/schemas/artifact.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import uuid
+
+from harness.models.enums import ArtifactKind
+from harness.schemas.common import IdModel
+
+
+class ArtifactOut(IdModel):
+    workspace_id: uuid.UUID
+    session_id: uuid.UUID | None = None
+    run_id: uuid.UUID | None = None
+    kind: ArtifactKind
+    uri: str
+    sha256: str
+    size: int
+    meta: dict

harness/schemas/common.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ORMModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+
+class IdModel(ORMModel):
+    id: uuid.UUID
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class Message(BaseModel):
+    message: str

harness/schemas/memory.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import uuid
+
+from pydantic import BaseModel, Field
+
+from harness.models.enums import MemoryScope, MemoryType
+
+
+class MemoryIngestRequest(BaseModel):
+    workspace: str = "default"
+    content: str
+    type: MemoryType = MemoryType.fact
+    scope: MemoryScope = MemoryScope.workspace
+    session_id: str | None = None
+    project: str | None = None
+    tags: list[str] = Field(default_factory=list)
+
+
+class MemoryItemOut(BaseModel):
+    id: uuid.UUID
+    namespace: str
+    scope: MemoryScope
+    type: MemoryType
+    content: str
+    tags: list[str]
+    redacted: bool
+
+
+class MemorySearchRequest(BaseModel):
+    workspace: str = "default"
+    query: str
+    session_id: str | None = None
+    project: str | None = None
+    top_k: int = 8
+
+
+class MemoryHit(BaseModel):
+    item_id: str
+    namespace: str
+    type: str
+    content: str
+    similarity: float
+    score: float
+
+
+class MemorySearchResponse(BaseModel):
+    query: str
+    hits: list[MemoryHit]
+    context_block: str

harness/schemas/policy.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import uuid
+
+from pydantic import BaseModel, Field
+
+from harness.models.enums import ApprovalStatus, PolicyKind
+
+
+class PolicySetRequest(BaseModel):
+    workspace: str = "default"
+    name: str
+    kind: PolicyKind
+    spec: dict = Field(default_factory=dict)
+    priority: int = 0
+
+
+class PolicyOut(BaseModel):
+    id: uuid.UUID
+    workspace_id: uuid.UUID
+    name: str
+    kind: PolicyKind
+    spec: dict
+    priority: int
+
+
+class ApprovalDecision(BaseModel):
+    status: ApprovalStatus
+    decided_by: str = "cli"
+
+
+class ApprovalOut(BaseModel):
+    id: uuid.UUID
+    session_id: uuid.UUID
+    run_id: uuid.UUID | None = None
+    action_class: str
+    payload: dict
+    status: ApprovalStatus
+    decided_by: str | None = None