arraylake 1.0.3a1__tar.gz → 1.1.0__tar.gz

{arraylake-1.0.3a1 → arraylake-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraylake
-Version: 1.0.3a1
+Version: 1.1.0
 Summary: Python client for ArrayLake
 Project-URL: Documentation, https://docs.earthmover.io/
 Project-URL: Changelog, https://docs.earthmover.io/changelog

{arraylake-1.0.3a1 → arraylake-1.1.0}/arraylake/_credential_cache.py

@@ -10,17 +10,24 @@ Validity follows ``Cache-Control: max-age`` semantics: cached creds are
 served while ``expires_at - CLOCK_SKEW_SAFETY > now``. The 30s safety only
 protects against worker/server NTP-level clock drift; it is not a
 pre-refresh window.
+
+The cache is loop-agnostic: callers may live on any asyncio event loop in
+the process. In-flight refreshes are coalesced via the singleflight
+pattern using a single ``concurrent.futures.Future`` per key as the shared
+result channel; each waiter bridges into its own loop via
+``asyncio.wrap_future``. The race for who runs the fetcher is resolved by
+``dict.setdefault``, which is atomic under the CPython GIL.
 """
 
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 from typing import Literal
 
-from arraylake.asyn import get_background_loop
 from arraylake.log_util import get_logger
 from arraylake.types import OrgName, Platform, TempCredentials
 
@@ -34,7 +41,7 @@ CLOCK_SKEW_SAFETY = timedelta(seconds=30)
 class CredentialCacheKey:
     api_url: str
     auth_key: int
-    scope: Literal["repo", "bucket"]
+    scope: Literal["repo", "bucket", "vcc"]
     org: OrgName
     identifier: str
     platform: Platform
@@ -43,12 +50,20 @@ class CredentialCacheKey:
 
 @dataclass
 class _Entry:
-    lock: asyncio.Lock = field(default_factory=asyncio.Lock)
-    creds: TempCredentials | None = None
-    expires_at: datetime | None = None
+    creds: TempCredentials
+    expires_at: datetime | None
 
 
 _CACHE: dict[CredentialCacheKey, _Entry] = {}
+_INFLIGHT: dict[CredentialCacheKey, concurrent.futures.Future[TempCredentials]] = {}
+
+
+def _fresh(entry: _Entry | None, now: datetime) -> TempCredentials | None:
+    if entry is None or entry.expires_at is None:
+        return None
+    if entry.expires_at - CLOCK_SKEW_SAFETY > now:
+        return entry.creds
+    return None
 
 
 async def get_or_refresh(
@@ -57,18 +72,29 @@ async def get_or_refresh(
     *,
     use_cache: bool = True,
 ) -> TempCredentials:
-    assert asyncio.get_running_loop() is get_background_loop(), "credential cache must be used from the arraylake background loop"
     if not use_cache:
         return await fetcher()
-    entry = _CACHE.setdefault(key, _Entry())
-    async with entry.lock:
-        now = datetime.now(UTC)
-        if entry.creds is not None and entry.expires_at is not None and entry.expires_at - CLOCK_SKEW_SAFETY > now:
-            return entry.creds
+
+    cached = _fresh(_CACHE.get(key), datetime.now(UTC))
+    if cached is not None:
+        return cached
+
+    my_future: concurrent.futures.Future[TempCredentials] = concurrent.futures.Future()
+    existing = _INFLIGHT.setdefault(key, my_future)
+    if existing is not my_future:
+        return await asyncio.wrap_future(existing)
+
+    try:
+        cached = _fresh(_CACHE.get(key), datetime.now(UTC))
+        if cached is not None:
+            my_future.set_result(cached)
+            return cached
+
         creds = await fetcher()
         exp = creds.expiration
         if exp is not None and exp.tzinfo is None:
             exp = exp.replace(tzinfo=UTC)
+        now = datetime.now(UTC)
         if exp is not None and exp - CLOCK_SKEW_SAFETY <= now:
             logger.warning(
                 "delegated credentials returned with lifetime <= clock-skew safety; server contract violation",
@@ -77,10 +103,25 @@ async def get_or_refresh(
                 org=key.org,
                 identifier=key.identifier,
             )
-        entry.creds = creds
-        entry.expires_at = exp
+        _CACHE[key] = _Entry(creds=creds, expires_at=exp)
+        my_future.set_result(creds)
         return creds
+    except BaseException as e:
+        my_future.set_exception(e)
+        raise
+    finally:
+        _INFLIGHT.pop(key, None)
+
+
+def populate(key: CredentialCacheKey, creds: TempCredentials) -> None:
+    exp = creds.expiration
+    if exp is not None and exp.tzinfo is None:
+        exp = exp.replace(tzinfo=UTC)
+    if _fresh(_CACHE.get(key), datetime.now(UTC)) is not None:
+        return
+    _CACHE[key] = _Entry(creds=creds, expires_at=exp)
 
 
 def clear() -> None:
     _CACHE.clear()
+    _INFLIGHT.clear()

{arraylake-1.0.3a1 → arraylake-1.1.0}/arraylake/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.3a1'
-__version_tuple__ = version_tuple = (1, 0, 3, 'a1')
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)
 
 __commit_id__ = commit_id = None

{arraylake-1.0.3a1 → arraylake-1.1.0}/arraylake/cli/main.py

@@ -6,6 +6,7 @@ from arraylake.cli.auth import auth
 from arraylake.cli.compute import app as compute_app
 from arraylake.cli.config import app as config_app
 from arraylake.cli.repo import app as repo_app
+from arraylake.cli.skills import app as skills_app
 from arraylake.cli.utils import rich_console
 from arraylake.diagnostics import get_diagnostics
 
@@ -44,3 +45,4 @@ app.add_typer(auth, name="auth")
 app.add_typer(repo_app, name="repo")
 app.add_typer(config_app, name="config")
 app.add_typer(compute_app, name="compute")
+app.add_typer(skills_app, name="skills")

arraylake-1.1.0/arraylake/cli/skills.py

@@ -0,0 +1,208 @@
+"""Install Arraylake Agent Skills into agent-specific skill directories.
+
+Skills follow the open Agent Skills spec (https://agentskills.io) and are
+hosted as static content on the Earthmover docs site. This command fetches
+the manifest, downloads each skill's files, and writes them into the
+directories agent skill loaders read from:
+
+- `~/.claude/skills/`  (Claude Code, opencode via compat shim)
+- `~/.agents/skills/`  (Codex, Cursor, Gemini CLI, and others)
+
+With `--project`, installs into `.claude/skills/` and `.agents/skills/`
+under the current working directory instead.
+
+Skill content ships independently of the `arraylake` client release. Re-run
+`arraylake skills install` to pick up new content; no `pip install -U`
+required.
+"""
+
+from __future__ import annotations
+
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+import typer
+from packaging.version import InvalidVersion, Version
+
+import arraylake
+from arraylake.cli.utils import rich_console
+from arraylake.config import config
+
+app = typer.Typer(help="Install Arraylake Agent Skills for AI coding agents")
+
+DEFAULT_SKILLS_URI = "https://docs.earthmover.io/skills"
+
+
+@dataclass(frozen=True)
+class SkillEntry:
+    name: str
+    version: str
+    min_client_version: str | None
+    description: str
+    files: tuple[str, ...]
+
+
+def _target_dirs(project: bool) -> list[Path]:
+    base = Path.cwd() if project else Path.home()
+    return [base / ".claude" / "skills", base / ".agents" / "skills"]
+
+
+def _skills_uri() -> str:
+    uri: str = config.get("skills.uri", DEFAULT_SKILLS_URI)
+    return uri.rstrip("/")
+
+
+def _client_version_ok(min_required: str | None) -> bool:
+    if not min_required:
+        return True
+    try:
+        return Version(arraylake.__version__) >= Version(min_required)
+    except InvalidVersion:
+        # Treat unparseable client versions (e.g. local dev builds without
+        # a tag) as "good enough" — don't block users on tooling weirdness.
+        return True
+
+
+def _parse_manifest(payload: dict) -> list[SkillEntry]:
+    entries: list[SkillEntry] = []
+    for raw in payload.get("skills", []):
+        entries.append(
+            SkillEntry(
+                name=raw["name"],
+                version=str(raw.get("version", "0.0")),
+                min_client_version=raw.get("min_client_version"),
+                description=str(raw.get("description", "")),
+                files=tuple(raw.get("files", [])),
+            )
+        )
+    return entries
+
+
+def _fetch_manifest(uri: str) -> list[SkillEntry]:
+    url = f"{uri}/manifest.json"
+    with httpx.Client(timeout=20.0, follow_redirects=True) as client:
+        resp = client.get(url)
+        resp.raise_for_status()
+        return _parse_manifest(resp.json())
+
+
+def _empty_temporary_sibling(dest: Path, prefix: str) -> Path:
+    path = Path(tempfile.mkdtemp(prefix=prefix, dir=dest))
+    path.rmdir()
+    return path
+
+
+def _remove_path(path: Path) -> None:
+    if path.is_symlink() or path.is_file():
+        path.unlink()
+    elif path.exists():
+        shutil.rmtree(path)
+
+
+def _install_skill(uri: str, entry: SkillEntry, dest: Path) -> str:
+    """Download all of `entry.files` into `dest/<name>/...`.
+
+    Returns one-word status: written | conflict.
+    """
+    skill_root = dest / entry.name
+    if skill_root.exists() and not skill_root.is_dir():
+        return "conflict"
+
+    tmp_root = Path(tempfile.mkdtemp(prefix=".arraylake-skill-", dir=dest))
+    backup_root: Path | None = None
+
+    try:
+        with httpx.Client(timeout=30.0, follow_redirects=True) as client:
+            for rel in entry.files:
+                if ".." in rel.split("/") or rel.startswith("/"):
+                    raise RuntimeError(f"Refusing to write file outside skill root: {rel}")
+                file_url = f"{uri}/{entry.name}/{rel}"
+                resp = client.get(file_url)
+                resp.raise_for_status()
+                target = tmp_root / rel
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(resp.content)
+
+        if skill_root.exists() or skill_root.is_symlink():
+            # Pre-existing install, including legacy wheel-bundled symlinks.
+            # Move it aside only after every replacement file has downloaded.
+            backup_root = _empty_temporary_sibling(dest, ".arraylake-skill-backup-")
+            skill_root.replace(backup_root)
+
+        tmp_root.replace(skill_root)
+        if backup_root is not None:
+            _remove_path(backup_root)
+            backup_root = None
+        return "written"
+    except Exception:
+        if backup_root is not None and (backup_root.exists() or backup_root.is_symlink()):
+            if skill_root.exists() or skill_root.is_symlink():
+                _remove_path(skill_root)
+            backup_root.replace(skill_root)
+            backup_root = None
+        raise
+    finally:
+        if tmp_root.exists() or tmp_root.is_symlink():
+            _remove_path(tmp_root)
+
+
+@app.command()
+def install(
+    project: bool = typer.Option(False, "--project", help="Install into the current directory instead of $HOME."),
+    url: str | None = typer.Option(
+        None,
+        "--url",
+        help=f"Override the skills server URL. Default: skills.uri config or {DEFAULT_SKILLS_URI}.",
+    ),
+) -> None:
+    """**Install** Arraylake skills into agent skill directories.
+
+    Default: user scope (`~/.claude/skills/` and `~/.agents/skills/`).
+    With `--project`: project scope under the current working directory.
+
+    Fetches the latest published skills from the Earthmover docs site
+    (configurable via `--url` or the `skills.uri` config key). Re-run this
+    to pick up content updates — they ship independently of the `arraylake`
+    package release cycle.
+    """
+    uri = (url or _skills_uri()).rstrip("/")
+    rich_console.print(f"Fetching skill manifest from [cyan]{uri}/manifest.json[/cyan]")
+    try:
+        entries = _fetch_manifest(uri)
+    except httpx.HTTPError as err:
+        rich_console.print(f"[red]Failed to fetch skills from {uri}: {err}[/red]")
+        raise typer.Exit(code=1) from err
+
+    if not entries:
+        rich_console.print("[yellow]Manifest contained no skills; nothing to install.[/yellow]")
+        return
+
+    ok = True
+    for target in _target_dirs(project):
+        target.mkdir(parents=True, exist_ok=True)
+        for entry in entries:
+            if not _client_version_ok(entry.min_client_version):
+                rich_console.print(
+                    f"[yellow]skip[/yellow]    {target / entry.name} "
+                    f"(skill requires arraylake>={entry.min_client_version}, "
+                    f"installed {arraylake.__version__})"
+                )
+                continue
+            try:
+                status = _install_skill(uri, entry, target)
+            except httpx.HTTPError as err:
+                rich_console.print(f"[red]error[/red]   {target / entry.name}: {err}")
+                ok = False
+                continue
+            if status == "conflict":
+                ok = False
+                rich_console.print(f"[yellow]skip[/yellow]    {target / entry.name} (path exists and is not a directory)")
+            else:
+                rich_console.print(f"[green]{status:8}[/green]{target / entry.name}")
+
+    if not ok:
+        rich_console.print("\n[yellow]One or more skills were skipped. Resolve the conflicts above and re-run.[/yellow]")
+        raise typer.Exit(code=1)