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

agent_toolkit/installer/receipt.py

@@ -0,0 +1,89 @@
+"""Installation receipt management — records what was installed and where."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Literal
+
+RECEIPT_DIR = Path.home() / ".config" / "agent-toolkit" / "receipts"
+
+
+@dataclass
+class ArtifactEntry:
+    path: str
+    digest: str
+    ownership: Literal["created", "merged"]
+
+
+@dataclass
+class InstallReceipt:
+    schema_version: int
+    product: str
+    target: str
+    scope: str
+    version: str
+    installed_at: str
+    source_digest: str
+    artifacts: list[ArtifactEntry] = field(default_factory=list)
+    config_patches: list[dict] = field(default_factory=list)
+    secrets: list = field(default_factory=list)  # always empty
+
+    @classmethod
+    def create(cls, product, target, scope, version, source_digest):
+        return cls(
+            schema_version=1,
+            product=product,
+            target=target,
+            scope=scope,
+            version=version,
+            installed_at=datetime.now(timezone.utc).isoformat(),
+            source_digest=source_digest,
+        )
+
+    def to_dict(self):
+        return {
+            "schemaVersion": self.schema_version,
+            "product": self.product,
+            "target": self.target,
+            "scope": self.scope,
+            "version": self.version,
+            "installedAt": self.installed_at,
+            "sourceDigest": self.source_digest,
+            "artifacts": [
+                {"path": a.path, "digest": a.digest, "ownership": a.ownership}
+                for a in self.artifacts
+            ],
+            "configPatches": self.config_patches,
+            "secrets": [],
+        }
+
+    def save(self, receipt_dir=None):
+        d = Path(receipt_dir) if receipt_dir else RECEIPT_DIR
+        d.mkdir(parents=True, exist_ok=True)
+        p = d / f"{self.target}-{self.product}.json"
+        p.write_text(json.dumps(self.to_dict(), indent=2) + "\n")
+        return p
+
+    @classmethod
+    def load(cls, target, product, receipt_dir=None):
+        d = Path(receipt_dir) if receipt_dir else RECEIPT_DIR
+        p = d / f"{target}-{product}.json"
+        if not p.exists():
+            return None
+        data = json.loads(p.read_text())
+        r = cls(
+            schema_version=data.get("schemaVersion", 1),
+            product=data["product"],
+            target=data["target"],
+            scope=data.get("scope", "project"),
+            version=data["version"],
+            installed_at=data.get("installedAt", ""),
+            source_digest=data.get("sourceDigest", ""),
+        )
+        for a in data.get("artifacts", []):
+            r.artifacts.append(ArtifactEntry(a["path"], a["digest"], a["ownership"]))
+        r.config_patches = list(data.get("configPatches", []))
+        return r

agent_toolkit/installer/sources.py

@@ -0,0 +1,92 @@
+"""Resolve install source paths — prefer compiler-generated plugins/ over hand profiles/."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from agent_toolkit._paths import toolkit_root
+
+# Default products whose compiled agents are installed for profile-based targets.
+_DEFAULT_AGENT_PRODUCTS = (
+    "agent-toolkit-core",
+    "agent-toolkit-agents",
+    "agent-toolkit-forge",
+)
+
+
+def find_repo_root(data_root: Path | None = None) -> Path:
+    """Return repo root containing plugins/ compiler output."""
+    root = data_root or toolkit_root()
+    if (root / "plugins").is_dir():
+        return root
+    if (root.parent / "plugins").is_dir():
+        return root.parent
+    return root
+
+
+def plugins_dir(data_root: Path | None = None) -> Path | None:
+    """Return plugins/ output directory when compiler artifacts are present."""
+    override = os.environ.get("AGENT_TOOLKIT_INSTALL_SOURCE", "").strip()
+    if override:
+        path = Path(override)
+        return path if path.is_dir() else None
+
+    repo = find_repo_root(data_root)
+    plugins = repo / "plugins"
+    return plugins if plugins.is_dir() else None
+
+
+def compiled_agent_files(
+    data_root: Path | None = None,
+    *,
+    products: tuple[str, ...] = _DEFAULT_AGENT_PRODUCTS,
+) -> dict[str, Path]:
+    """Map agent name -> AGENT.md path from compiled plugin bundles."""
+    root = data_root or toolkit_root()
+    plugins = root / "plugins"
+    if not plugins.is_dir():
+        repo_plugins = plugins_dir(data_root)
+        if repo_plugins is None:
+            return {}
+        plugins = repo_plugins
+
+    agents: dict[str, Path] = {}
+    for product_id in products:
+        agents_dir = plugins / product_id / "agents"
+        if not agents_dir.is_dir():
+            continue
+        for agent_dir in sorted(agents_dir.iterdir()):
+            if not agent_dir.is_dir():
+                continue
+            agent_md = agent_dir / "AGENT.md"
+            if agent_md.is_file():
+                agents[agent_dir.name] = agent_md
+    return agents
+
+
+def agent_install_sources(
+    tool: str,
+    data_root: Path | None = None,
+) -> dict[str, Path]:
+    """Return agent-name -> source file for a profile install target.
+
+    Prefers compiler-generated ``plugins/*/agents/*/AGENT.md`` artifacts.
+    Falls back to ``profiles/<tool>/agents/*.md`` when plugins are unavailable.
+    """
+    compiled = compiled_agent_files(data_root)
+    if compiled:
+        return compiled
+
+    root = data_root or toolkit_root()
+    profile_agents = root / "profiles" / tool / "agents"
+    if not profile_agents.is_dir():
+        return {}
+
+    return {path.stem: path for path in sorted(profile_agents.glob("*.md")) if path.is_file()}
+
+
+def profile_file(tool: str, *parts: str, data_root: Path | None = None) -> Path:
+    """Return a profile-relative path (rules, CLAUDE.md, etc.)."""
+    root = data_root or toolkit_root()
+    return root / "profiles" / tool / Path(*parts)

agent_toolkit/installer/tracking.py

@@ -0,0 +1,63 @@
+"""Track installed artifacts and persist InstallReceipt."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from agent_toolkit import __version__
+from agent_toolkit.installer.receipt import ArtifactEntry, InstallReceipt
+
+PRODUCT = "agent-toolkit-profiles"
+SCOPE = "user-home"
+
+
+def receipt_dir() -> Path:
+    """Return the install receipt directory (under the current HOME)."""
+    return Path.home() / ".config" / "agent-toolkit" / "receipts"
+
+
+def file_digest(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()[:16]
+
+
+def source_digest(root: Path) -> str:
+    marker = root / "profiles"
+    if marker.is_dir():
+        return hashlib.sha256(str(marker.resolve()).encode()).hexdigest()[:12]
+    return __version__
+
+
+class InstallTracker:
+    """Collect artifact entries during install and write receipt on save."""
+
+    def __init__(
+        self,
+        target: str,
+        *,
+        dry_run: bool,
+        receipt_dir_path: Path | None = None,
+        toolkit_root: Path | None = None,
+    ) -> None:
+        root = toolkit_root or Path()
+        self.dry_run = dry_run
+        self.receipt_dir_path = receipt_dir_path or receipt_dir()
+        self.receipt = InstallReceipt.create(
+            PRODUCT,
+            target,
+            SCOPE,
+            __version__,
+            source_digest(root),
+        )
+
+    def record_created(self, path: Path) -> None:
+        if not path.is_file():
+            return
+        self.receipt.artifacts.append(
+            ArtifactEntry(str(path.resolve()), file_digest(path), "created")
+        )
+
+    def save(self) -> Path | None:
+        if self.dry_run or not self.receipt.artifacts:
+            return None
+        return self.receipt.save(self.receipt_dir_path)

agent_toolkit/launcher.py

@@ -0,0 +1,69 @@
+"""Thin PyPI launcher — replace this process with the bundled V binary (ADR-021 / #535).
+
+No Python business logic. Product commands agent-toolkit and agent-toolkit-cli
+hand off to the native binary.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+_BIN_DIR = Path(__file__).resolve().parent / "bin"
+_NATIVE_NAMES = ("agent-toolkit.exe", "agent-toolkit")
+
+
+def bundled_binary() -> Path | None:
+    for name in _NATIVE_NAMES:
+        cand = _BIN_DIR / name
+        if cand.is_file():
+            return cand
+    return None
+
+
+def resolve_native_bin() -> Path | None:
+    env = os.environ.get("AGENT_TOOLKIT_BIN", "").strip()
+    if env:
+        p = Path(env)
+        if p.is_file():
+            return p
+        return None
+    bundled = bundled_binary()
+    if bundled is not None:
+        return bundled
+    root = os.environ.get("AGENT_TOOLKIT_ROOT", "").strip()
+    if root:
+        for rel in ("build/agent-toolkit", "build/agent-toolkit-v", "build/agent-toolkit.exe"):
+            cand = Path(root) / rel
+            if cand.is_file():
+                return cand
+    return None
+
+
+def run_native(bin_path: Path, rest: list[str]) -> None:
+    argv = [str(bin_path), *rest]
+    if os.name == "nt":
+        proc = subprocess.run(argv, check=False)
+        raise SystemExit(int(proc.returncode))
+    os.execv(argv[0], argv)
+
+
+def missing_binary_message() -> str:
+    return (
+        "agent-toolkit: native V binary not found (ADR-021).\n"
+        "  Packaged wheels bundle the binary under agent_toolkit/bin/.\n"
+        "  Dev: make build-cli, or set AGENT_TOOLKIT_BIN to that executable.\n"
+        "  Python implementation (fallback): agent-toolkit-py\n"
+    )
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = list(sys.argv if argv is None else argv)
+    rest = args[1:] if len(args) > 1 else []
+    bin_path = resolve_native_bin()
+    if bin_path is None:
+        sys.stderr.write(missing_binary_message())
+        raise SystemExit(127)
+    run_native(bin_path, rest)

agent_toolkit/loop/budget.py

@@ -0,0 +1,107 @@
+"""Loop budget helpers: wall-clock timeout and token accounting."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+DEFAULT_WALL_SECONDS = 900
+
+
+def wall_timeout_seconds(budget: dict[str, Any]) -> int:
+    """Per-run wall-clock limit from loop budget (never bypassed by --force)."""
+    raw = budget.get("max_wall_seconds")
+    if raw is None:
+        return DEFAULT_WALL_SECONDS
+    try:
+        return max(30, int(raw))
+    except (TypeError, ValueError):
+        return DEFAULT_WALL_SECONDS
+
+
+def max_tokens_limit(budget: dict[str, Any]) -> int | None:
+    """Per-run token ceiling, or None when unset."""
+    raw = budget.get("max_tokens")
+    if raw is None:
+        return None
+    try:
+        return int(raw)
+    except (TypeError, ValueError):
+        return None
+
+
+def tokens_from_trace(trace_path: Path) -> int:
+    """Sum token_usage / prompt+completion events from a trace.jsonl file."""
+    if not trace_path.is_file():
+        return 0
+    total = 0
+    for line in trace_path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        kind = event.get("kind", "")
+        if kind == "token_usage":
+            total += int(event.get("total_tokens") or event.get("total") or 0)
+        elif kind in ("prompt", "completion"):
+            total += int(event.get("prompt_tokens", 0) or 0)
+            total += int(event.get("completion_tokens", 0) or 0)
+    return total
+
+
+def tokens_today(loop_dir: Path) -> int:
+    """Sum tokens recorded in today's run traces under loop_dir/runs/."""
+    runs_dir = loop_dir / "runs"
+    if not runs_dir.is_dir():
+        return 0
+    today = datetime.now(timezone.utc).date()
+    total = 0
+    for run in runs_dir.iterdir():
+        if not run.is_dir():
+            continue
+        trace = run / "trace.jsonl"
+        if not trace.is_file():
+            continue
+        try:
+            first_line = trace.read_text(encoding="utf-8").splitlines()[0]
+            event = json.loads(first_line)
+            ts = event.get("ts", "")
+            if ts:
+                run_day = datetime.fromisoformat(str(ts).replace("Z", "+00:00")).date()
+                if run_day != today:
+                    continue
+        except (IndexError, json.JSONDecodeError, ValueError):
+            pass
+        total += tokens_from_trace(trace)
+    return total
+
+
+def token_budget_exceeded(tokens_used: int, budget: dict[str, Any]) -> bool:
+    limit = max_tokens_limit(budget)
+    if limit is None:
+        return False
+    return tokens_used >= limit
+
+
+def soft_token_precheck(state: dict[str, Any], budget: dict[str, Any]) -> str | None:
+    """Warn when last run tokens suggest the next run may hit max_tokens immediately."""
+    limit = max_tokens_limit(budget)
+    if limit is None:
+        return None
+    last_tokens = state.get("last_run_tokens")
+    if last_tokens is None:
+        return None
+    try:
+        last = int(last_tokens)
+    except (TypeError, ValueError):
+        return None
+    if last >= limit:
+        return (
+            f"Last run used {last:,} tokens (limit {limit:,}). Run may exit with budget_exhausted."
+        )
+    return None