agentdir-cli 0.7.5__py3-none-any.whl

agentdir/store.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+STORE_VERSION = "0.1"
+CONFIG_DIR = ".agentdir"
+INDEX_FILE = "agentdir.sqlite3"
+SCOPE_CHOICES = ("project", "user", "global", "machine")
+
+_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._@+-]{0,127}$")
+
+
+class AgentDirError(Exception):
+    """Base exception for user-facing AgentDir failures."""
+
+
+@dataclass(frozen=True)
+class RootPaths:
+    root: Path
+    meta: Path
+    sessions: Path
+    actors: Path
+    queues: Path
+    artifacts: Path
+    archives: Path
+    indexes: Path
+    state: Path
+    hooks: Path
+    integrations: Path
+
+    @property
+    def index_path(self) -> Path:
+        return self.indexes / INDEX_FILE
+
+
+def normalize_root(root: str | Path) -> Path:
+    return Path(root).expanduser().resolve()
+
+
+def paths_for(root: str | Path) -> RootPaths:
+    root_path = normalize_root(root)
+    meta_path = root_path
+    legacy_meta = root_path / CONFIG_DIR
+    if not (root_path / "VERSION").exists() and (legacy_meta / "VERSION").exists():
+        meta_path = legacy_meta
+    return RootPaths(
+        root=root_path,
+        meta=meta_path,
+        sessions=root_path / "sessions",
+        actors=root_path / "actors",
+        queues=root_path / "queues",
+        artifacts=root_path / "artifacts",
+        archives=root_path / "archives",
+        indexes=root_path / "indexes",
+        state=root_path / "state",
+        hooks=root_path / "hooks",
+        integrations=root_path / "integrations",
+    )
+
+
+def find_project_base(cwd: str | Path | None = None) -> Path:
+    start = Path(cwd or Path.cwd()).expanduser().resolve()
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=start,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return Path(result.stdout.strip()).resolve()
+    except OSError:
+        pass
+    return start
+
+
+def machine_root() -> Path:
+    override = os.environ.get("AGENTDIR_MACHINE_ROOT")
+    if override:
+        return normalize_root(override)
+    legacy = _legacy_machine_root()
+    if legacy.exists():
+        return legacy
+    candidate = _platform_site_data_path()
+    if candidate is not None:
+        return candidate
+    return legacy
+
+
+def user_root() -> Path:
+    override = os.environ.get("AGENTDIR_USER_ROOT")
+    if override:
+        return normalize_root(override)
+    legacy = Path.home().expanduser().resolve() / CONFIG_DIR
+    if legacy.exists():
+        return legacy
+    candidate = _platform_user_data_path()
+    if candidate is not None:
+        return candidate
+    return _fallback_user_data_path()
+
+
+def _legacy_machine_root() -> Path:
+    if platform.system() == "Darwin":
+        return Path("/Library/Application Support/AgentDir").resolve()
+    return Path("/var/lib/agentdir").resolve()
+
+
+def _platform_user_data_path() -> Path | None:
+    try:
+        from platformdirs import user_data_path
+    except ImportError:
+        return None
+    return Path(user_data_path("AgentDir", appauthor=False)).expanduser().resolve()
+
+
+def _platform_site_data_path() -> Path | None:
+    try:
+        from platformdirs import site_data_path
+    except ImportError:
+        return None
+    return Path(site_data_path("AgentDir", appauthor=False)).expanduser().resolve()
+
+
+def _fallback_user_data_path() -> Path:
+    if platform.system() == "Darwin":
+        return (Path.home().expanduser() / "Library" / "Application Support" / "AgentDir").resolve()
+    xdg = os.environ.get("XDG_DATA_HOME")
+    if xdg:
+        return (Path(xdg).expanduser() / "AgentDir").resolve()
+    return (Path.home().expanduser() / ".local" / "share" / "AgentDir").resolve()
+
+
+def root_for_scope(scope: str | None = None, cwd: str | Path | None = None) -> Path:
+    selected = scope or os.environ.get("AGENTDIR_SCOPE") or "project"
+    if selected not in SCOPE_CHOICES:
+        raise AgentDirError(
+            f"Invalid scope {selected!r}; expected one of {', '.join(SCOPE_CHOICES)}"
+        )
+    if selected == "project":
+        return find_project_base(cwd) / CONFIG_DIR
+    if selected in {"user", "global"}:
+        return user_root()
+    return machine_root()
+
+
+def resolve_root(
+    root: str | Path | None = None,
+    scope: str | None = None,
+    cwd: str | Path | None = None,
+) -> Path:
+    if root is not None:
+        return normalize_root(root)
+    if scope is None and os.environ.get("AGENTDIR_ROOT"):
+        return normalize_root(os.environ["AGENTDIR_ROOT"])
+    return root_for_scope(scope, cwd)
+
+
+def validate_id(value: str, label: str = "id") -> str:
+    if not _ID_RE.match(value) or "/" in value or ":" in value or value.startswith("."):
+        raise AgentDirError(
+            f"Invalid {label} {value!r}; use filesystem-safe letters, numbers, dot, underscore, at, plus, or dash"
+        )
+    return value
+
+
+def ensure_mailbox(path: Path) -> Path:
+    for name in ("tmp", "new", "cur"):
+        (path / name).mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def is_mailbox(path: Path) -> bool:
+    return all((path / name).is_dir() for name in ("tmp", "new", "cur"))
+
+
+def init_root(root: str | Path) -> RootPaths:
+    paths = paths_for(root)
+    paths.root.mkdir(parents=True, exist_ok=True)
+    for directory in (
+        paths.meta,
+        paths.sessions,
+        paths.actors,
+        paths.queues,
+        paths.artifacts / "blobs" / "sha256",
+        paths.archives / "sessions",
+        paths.indexes,
+        paths.state,
+        paths.hooks,
+        paths.integrations,
+    ):
+        directory.mkdir(parents=True, exist_ok=True)
+
+    version_path = paths.meta / "VERSION"
+    if version_path.exists():
+        current = version_path.read_text(encoding="utf-8").strip()
+        if current != STORE_VERSION:
+            raise AgentDirError(
+                f"Unsupported AgentDir root version {current!r}; expected {STORE_VERSION}"
+            )
+    else:
+        version_path.write_text(f"{STORE_VERSION}\n", encoding="utf-8")
+
+    config_path = paths.meta / "config.json"
+    if not config_path.exists():
+        config = {"version": STORE_VERSION, "index": str(paths.index_path.relative_to(paths.root))}
+        config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+    return paths
+
+
+def require_root(root: str | Path) -> RootPaths:
+    paths = paths_for(root)
+    if not (paths.meta / "VERSION").is_file():
+        raise AgentDirError(f"Not an AgentDir root: {paths.root}")
+    return paths
+
+
+def session_mailbox(root: str | Path, session_id: str, create: bool = True) -> Path:
+    paths = require_root(root)
+    validate_id(session_id, "session id")
+    mailbox = paths.sessions / session_id / "Maildir"
+    if create:
+        ensure_mailbox(mailbox)
+    return mailbox
+
+
+def actor_dir(root: str | Path, actor_id: str) -> Path:
+    paths = require_root(root)
+    validate_id(actor_id, "actor id")
+    return paths.actors / actor_id
+
+
+def actor_mailbox(root: str | Path, actor_id: str, box: str, create: bool = True) -> Path:
+    if box not in {"inbox", "outbox"}:
+        raise AgentDirError(f"Unknown actor mailbox {box!r}")
+    mailbox = actor_dir(root, actor_id) / box / "Maildir"
+    if create:
+        ensure_mailbox(mailbox)
+    return mailbox
+
+
+def queue_mailbox(root: str | Path, queue_id: str, create: bool = True) -> Path:
+    paths = require_root(root)
+    validate_id(queue_id, "queue id")
+    mailbox = paths.queues / queue_id / "Maildir"
+    if create:
+        ensure_mailbox(mailbox)
+    return mailbox
+
+
+def discover_mailboxes(root: str | Path) -> list[tuple[str, Path]]:
+    paths = require_root(root)
+    discovered: list[tuple[str, Path]] = []
+    for session in sorted(paths.sessions.glob("*/Maildir")):
+        if is_mailbox(session):
+            discovered.append(("session", session))
+    for actor_box in sorted(paths.actors.glob("*/*/Maildir")):
+        if is_mailbox(actor_box):
+            discovered.append(("actor", actor_box))
+    for queue in sorted(paths.queues.glob("*/Maildir")):
+        if is_mailbox(queue):
+            discovered.append(("queue", queue))
+    return discovered

agentdir/upgrade.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .store import AgentDirError
+
+DEFAULT_REPO = "jstxn/agentdir"
+
+
+@dataclass(frozen=True)
+class UpgradeOptions:
+    repo: str = DEFAULT_REPO
+    version: str | None = None
+    adopt: bool = True
+    install_skill: str = "user"
+    hooks: bool = True
+    dry_run: bool = False
+
+
+def upgrade_agentdir(options: UpgradeOptions) -> dict[str, Any]:
+    target_version = options.version or _latest_release_tag(options.repo, dry_run=options.dry_run)
+    cwd = Path.cwd()
+    repo_root = _git_root(cwd) if options.adopt else None
+    before = _command_version(_agentdir_bin())
+    result: dict[str, Any] = {
+        "current_process_version": __version__,
+        "installed_version_before": before,
+        "target_version": target_version,
+        "repo": options.repo,
+        "dry_run": options.dry_run,
+        "install": {"planned": True, "ok": None},
+        "adopt": {
+            "planned": bool(repo_root),
+            "ok": None,
+            "root": str(repo_root) if repo_root else None,
+            "install_skill": options.install_skill,
+            "hooks": options.hooks,
+        },
+        "doctor": {"planned": bool(repo_root), "ok": None},
+    }
+    if options.dry_run:
+        result["install"]["command"] = _install_description(options.repo, target_version)
+        if repo_root:
+            result["adopt"]["command"] = _adopt_description(options.install_skill, options.hooks)
+        return result
+
+    install_output = _run_installer(options.repo, target_version)
+    result["install"].update({"ok": install_output.returncode == 0, "stderr": install_output.stderr})
+    if install_output.returncode != 0:
+        result["install"]["stdout"] = install_output.stdout
+        return result
+
+    agentdir_bin = _agentdir_bin()
+    after = _command_version(agentdir_bin)
+    result["installed_version_after"] = after
+    result["install"]["version_ok"] = _version_matches(after, target_version)
+    if repo_root:
+        adopt_output = _run_adopt(agentdir_bin, repo_root, options.install_skill, options.hooks)
+        result["adopt"].update(
+            {
+                "ok": adopt_output.returncode == 0,
+                "stdout": adopt_output.stdout,
+                "stderr": adopt_output.stderr,
+            }
+        )
+        doctor_output = subprocess.run(
+            [agentdir_bin, "doctor", "--json"],
+            cwd=repo_root,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        doctor_payload = _json_or_text(doctor_output.stdout)
+        result["doctor"].update(
+            {
+                "ok": doctor_output.returncode == 0,
+                "result": doctor_payload,
+                "stderr": doctor_output.stderr,
+            }
+        )
+    return result
+
+
+def format_upgrade_result(result: dict[str, Any]) -> str:
+    lines = [
+        f"current_process_version={result['current_process_version']}",
+        f"installed_version_before={result.get('installed_version_before') or 'unknown'}",
+        f"target_version={result['target_version']}",
+    ]
+    if result["dry_run"]:
+        lines.append(f"install={result['install']['command']}")
+        if result["adopt"]["planned"]:
+            lines.append(f"adopt={result['adopt']['command']}")
+        else:
+            lines.append("adopt=skipped outside git repository")
+        return "\n".join(lines)
+
+    lines.append(f"install_ok={str(bool(result['install']['ok'])).lower()}")
+    if not result["install"]["ok"]:
+        lines.append("upgrade failed during reinstall")
+        return "\n".join(lines)
+    lines.append(f"installed_version_after={result.get('installed_version_after') or 'unknown'}")
+    lines.append(f"install_version_ok={str(bool(result['install'].get('version_ok'))).lower()}")
+    if result["adopt"]["planned"]:
+        lines.append(f"adopt_ok={str(bool(result['adopt']['ok'])).lower()}")
+        lines.append(f"adopt_root={result['adopt']['root']}")
+    else:
+        lines.append("adopt=skipped outside git repository")
+    if result["doctor"]["planned"]:
+        lines.append(f"doctor_ok={str(bool(result['doctor']['ok'])).lower()}")
+        doctor_result = result["doctor"].get("result")
+        if isinstance(doctor_result, dict):
+            for error in doctor_result.get("errors", []):
+                lines.append(f"doctor_error={error}")
+            for warning in doctor_result.get("warnings", []):
+                lines.append(f"doctor_warning={warning}")
+    return "\n".join(lines)
+
+
+def upgrade_exit_code(result: dict[str, Any]) -> int:
+    if result["dry_run"]:
+        return 0
+    if not result["install"]["ok"]:
+        return 1
+    if not result["install"].get("version_ok"):
+        return 1
+    if result["adopt"]["planned"] and not result["adopt"]["ok"]:
+        return 1
+    if result["doctor"]["planned"] and not result["doctor"]["ok"]:
+        return 1
+    return 0
+
+
+def _latest_release_tag(repo: str, *, dry_run: bool) -> str:
+    if dry_run:
+        return "latest"
+    result = subprocess.run(
+        ["gh", "api", f"repos/{repo}/releases/latest", "--jq", ".tag_name"],
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode != 0 or not result.stdout.strip():
+        raise AgentDirError(result.stderr.strip() or f"could not resolve latest release for {repo}")
+    return result.stdout.strip()
+
+
+def _run_installer(repo: str, version: str) -> subprocess.CompletedProcess[str]:
+    with tempfile.TemporaryDirectory(prefix="agentdir-upgrade.") as tmp:
+        install_script = Path(tmp) / "install-agentdir.sh"
+        fetch = subprocess.run(
+            [
+                "gh",
+                "api",
+                "-H",
+                "Accept: application/vnd.github.raw",
+                f"repos/{repo}/contents/scripts/install.sh?ref={version}",
+            ],
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if fetch.returncode != 0:
+            return fetch
+        install_script.write_text(fetch.stdout, encoding="utf-8")
+        install_script.chmod(0o700)
+        env = os.environ.copy()
+        env["AGENTDIR_REPO"] = repo
+        env["AGENTDIR_VERSION"] = version
+        env["AGENTDIR_WHEEL"] = ""
+        return subprocess.run(
+            ["bash", str(install_script)],
+            text=True,
+            capture_output=True,
+            check=False,
+            env=env,
+        )
+
+
+def _run_adopt(
+    agentdir_bin: str,
+    repo_root: Path,
+    install_skill: str,
+    hooks: bool,
+) -> subprocess.CompletedProcess[str]:
+    command = [agentdir_bin, "adopt", "--install-skill", install_skill]
+    if not hooks:
+        command.append("--no-hooks")
+    return subprocess.run(command, cwd=repo_root, text=True, capture_output=True, check=False)
+
+
+def _git_root(cwd: Path) -> Path | None:
+    result = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        cwd=cwd,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode != 0 or not result.stdout.strip():
+        return None
+    return Path(result.stdout.strip()).resolve()
+
+
+def _agentdir_bin() -> str:
+    invoked = Path(sys.argv[0])
+    if invoked.name == "agentdir" and invoked.exists():
+        return str(invoked.resolve())
+    return shutil.which("agentdir") or str(Path.home() / ".local" / "bin" / "agentdir")
+
+
+def _command_version(command: str) -> str | None:
+    try:
+        result = subprocess.run([command, "--version"], text=True, capture_output=True, check=False)
+    except OSError:
+        return None
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def _version_matches(version_output: str | None, target_version: str) -> bool:
+    if not version_output:
+        return False
+    return target_version.lstrip("v") in version_output
+
+
+def _json_or_text(text: str) -> Any:
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return text
+
+
+def _install_description(repo: str, version: str) -> str:
+    return f"install {repo}@{version}"
+
+
+def _adopt_description(install_skill: str, hooks: bool) -> str:
+    command = f"agentdir adopt --install-skill {install_skill}"
+    if not hooks:
+        command += " --no-hooks"
+    return command