@junghanacs/entwurf 0.12.5 → 0.12.7

package/scripts/agy-statusline-config.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""agy-statusline-config — JSON state ops for the agy (Antigravity) statusLine install adapter
+(#46 Task 1). SEPARATE from agy-bridge (mcp_config) and from the Claude meta-bridge; only the
+reporting/runner shell is shared. stdlib only.
+
+Owns the WHOLE `statusLine` subtree of agy's settings.json (봉인계약 4 statusLine판 + GPT G5-2:
+statusLine.command partial-ownership collides with whole-subtree ownership). The command written
+is ALWAYS the bare stable bin `entwurf-agy-statusline` (dev AND installed — #46 tripwire; the
+checkout path lives only in the dev-bin symlink state, never in this settings file).
+
+Subcommands (argv[1]):
+  install   <settings_path> <command> <state_path>
+      Adopt agy settings.json and set statusLine = {type:"custom", command:<command>,
+      enabled:true} (the WHOLE subtree). REFUSES a symlink target (exit 3 — someone else's SSOT,
+      e.g. an agent-config link). The prior statusLine subtree (or None if absent) is captured as
+      the preimage for an honest inverse. Unrelated keys (model/permissions/…) are preserved.
+      Absent file is created. Invalid JSON fails loud (exit 4). Writes install-state atomically.
+
+  uninstall <state_path>
+      Honest inverse: restore the captured statusLine preimage (remove the key if it was absent,
+      else set it back). If WE created the whole file and nothing else remains, remove it. REFUSES
+      if the settings file became a symlink since install (exit 3). No state → nothing (exit 2).
+
+  doctor-static <settings_path>
+      Print one shell-parseable status token line: `file-absent` / `absent` (file exists but
+      no statusLine command) / `invalid-json` / `not-ours` (statusLine present but command !=
+      entwurf-agy-statusline) / `configured <command>`. Never mutates.
+
+Exit codes: 0 ok · 2 no-state · 3 refuse-symlink · 4 invalid-json · 5 usage.
+"""
+
+import json
+import os
+import sys
+
+KEY = "statusLine"
+OUR_COMMAND = "entwurf-agy-statusline"
+STATE_SCHEMA_VERSION = 1
+
+
+def _die(code: int, msg: str) -> "None":
+    sys.stderr.write(msg.rstrip("\n") + "\n")
+    sys.exit(code)
+
+
+def _atomic_write(path: str, text: str) -> None:
+    os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+    tmp = f"{path}.tmp-{os.getpid()}"
+    with open(tmp, "w", encoding="utf-8") as fh:
+        fh.write(text)
+    os.replace(tmp, path)
+
+
+def _load(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as fh:
+        raw = fh.read()
+    if raw.strip() == "":
+        return {}
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as err:
+        _die(4, f"agy-statusline: {path} is not valid JSON: {err}")
+    if not isinstance(data, dict):
+        _die(4, f"agy-statusline: {path} top-level must be a JSON object")
+    return data
+
+
+def _dump(data: dict) -> str:
+    return json.dumps(data, indent=2) + "\n"
+
+
+def _now() -> str:
+    import datetime
+
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _prior_state(state_path: str, settings_path: str) -> dict:
+    """The state of OUR FIRST install of this exact settings file, if we are re-installing over it.
+
+    Empty dict when there is no prior install, or when the prior install managed a DIFFERENT path
+    (a re-target is a fresh install for that path, and its preimage must be captured anew).
+    """
+    if not os.path.exists(state_path):
+        return {}
+    prior = _load(state_path)
+    if prior.get("managedSettingsPath") != os.path.abspath(settings_path):
+        return {}
+    return prior
+
+
+def cmd_install(settings_path: str, command: str, state_path: str) -> None:
+    # REFUSE a symlink — someone else's SSOT (an agent-config link). Never clobber.
+    if os.path.islink(settings_path):
+        target = os.readlink(settings_path)
+        _die(3, f"agy-statusline: refusing to adopt {settings_path} — it is a symlink to {target} "
+                f"(someone else's SSOT). Manage it there, or replace it with a regular file, then retry.")
+
+    settings_existed = os.path.exists(settings_path)
+    if settings_existed:
+        data = _load(settings_path)
+        detect_mode = "adopt-regular-file"
+    else:
+        data = {}
+        detect_mode = "created-new"
+
+    # Capture the WHOLE prior statusLine subtree (None = absent) for the honest inverse — but ONLY
+    # on the first install of this target. An installer is re-run routinely (every package upgrade);
+    # re-capturing here would capture OUR OWN previous subtree as "what was there before", and
+    # uninstall would then faithfully restore us — leaving behind the exact thing it exists to
+    # remove. Provenance is a fact about a moment that has already passed: record it once, carry it.
+    prior = _prior_state(state_path, settings_path)
+    if prior:
+        preimage = prior.get("preimage", None)
+        detect_mode = prior.get("detectMode", detect_mode)
+        settings_existed = prior.get("settingsExistedBefore", settings_existed)
+    else:
+        preimage = data.get(KEY, None)
+    data[KEY] = {"type": "custom", "command": command, "enabled": True}
+
+    _atomic_write(settings_path, _dump(data))
+
+    state = {
+        "schemaVersion": STATE_SCHEMA_VERSION,
+        "managedSettingsPath": os.path.abspath(settings_path),
+        "key": KEY,
+        "command": command,
+        "detectMode": detect_mode,
+        "settingsExistedBefore": settings_existed,
+        "preimage": preimage,  # null = statusLine was absent before install
+        "installedAt": _now(),
+    }
+    _atomic_write(state_path, _dump(state))
+    sys.stdout.write(f"{detect_mode} {os.path.abspath(settings_path)}\n")
+
+
+def cmd_uninstall(state_path: str) -> None:
+    if not os.path.exists(state_path):
+        _die(2, f"agy-statusline: no install-state at {state_path} — nothing to uninstall "
+                f"(never installed, or already uninstalled).")
+    state = _load(state_path)
+    settings_path = state.get("managedSettingsPath")
+    if not isinstance(settings_path, str):
+        _die(4, f"agy-statusline: install-state {state_path} has no managedSettingsPath")
+
+    if os.path.islink(settings_path):
+        _die(3, f"agy-statusline: refusing to uninstall — {settings_path} became a symlink since "
+                f"install (someone else's SSOT now). Resolve by hand.")
+
+    if os.path.exists(settings_path):
+        data = _load(settings_path)
+        preimage = state.get("preimage", None)
+        if preimage is None:
+            data.pop(KEY, None)
+        else:
+            data[KEY] = preimage
+        # If WE created the whole file and nothing else remains, remove it (honest inverse).
+        created_new = state.get("detectMode") == "created-new" and state.get("settingsExistedBefore") is False
+        only_ours_empty = created_new and len(data) == 0
+        if only_ours_empty:
+            os.remove(settings_path)
+        else:
+            _atomic_write(settings_path, _dump(data))
+
+    os.remove(state_path)
+    sys.stdout.write(f"uninstalled {settings_path}\n")
+
+
+def cmd_doctor_static(settings_path: str) -> None:
+    real = os.path.realpath(settings_path)
+    if not os.path.exists(real):
+        sys.stdout.write("file-absent\n")
+        return
+    try:
+        with open(real, "r", encoding="utf-8") as fh:
+            data = json.loads(fh.read() or "{}")
+    except (json.JSONDecodeError, OSError):
+        sys.stdout.write("invalid-json\n")
+        return
+    sl = data.get(KEY) if isinstance(data, dict) else None
+    cmd = sl.get("command") if isinstance(sl, dict) else None
+    if not cmd:
+        sys.stdout.write("absent\n")
+        return
+    if cmd != OUR_COMMAND:
+        # present but points elsewhere (e.g. still the agent-config path) — not ours.
+        sys.stdout.write("not-ours\n")
+        return
+    sys.stdout.write(f"configured {cmd}\n")
+
+
+def main(argv: list) -> None:
+    if len(argv) < 2:
+        _die(5, "usage: agy-statusline-config.py <install|uninstall|doctor-static> ...")
+    sub = argv[1]
+    if sub == "install":
+        if len(argv) != 5:
+            _die(5, "usage: agy-statusline-config.py install <settings_path> <command> <state_path>")
+        cmd_install(argv[2], argv[3], argv[4])
+    elif sub == "uninstall":
+        if len(argv) != 3:
+            _die(5, "usage: agy-statusline-config.py uninstall <state_path>")
+        cmd_uninstall(argv[2])
+    elif sub == "doctor-static":
+        if len(argv) != 3:
+            _die(5, "usage: agy-statusline-config.py doctor-static <settings_path>")
+        cmd_doctor_static(argv[2])
+    else:
+        _die(5, f"agy-statusline-config.py: unknown subcommand {sub!r}")
+
+
+if __name__ == "__main__":
+    main(sys.argv)

package/scripts/agy-statusline.sh

@@ -0,0 +1,256 @@
+#!/usr/bin/env bash
+# agy-statusline — Antigravity (agy) native statusline with garden identity.
+#
+# The agy mirror of meta-bridge-statusline.sh (봉인 7: separate adapter, shared
+# PATTERN not code). It preserves GLG's ambient UX (device, cwd[branch], model,
+# context usage) and adds the garden id, looked up by the agy native
+# `conversation_id` (== `session_id`) against the meta-session record BODIES —
+# the SAME authority meta-bridge uses, no cwd back-match, no gid invention.
+#
+# Why a SEPARATE renderer (not the cc one): agy's stdin schema differs
+# (conversation_id / total_input_tokens / agent_state) and "cc" labels are
+# Claude-specific. The garden-lookup logic is duplicated deliberately for now;
+# extracting a shared helper is a follow-up (harness-specific honesty > DRY).
+#
+# The command written into agy settings.statusLine is ALWAYS the bare stable bin
+# `entwurf-agy-statusline` (dev AND installed) — never a repo/checkout path. dev
+# resolves it via `expose-dev-bin`; installed via the npm bin-link (#46 원문
+# tripwire; oracle dangling 교훈). This DIFFERS from meta-bridge's dev repo-path
+# branch, which is claude-side legacy by-design — claude 동형화는 후속 판단.
+#
+# Runtime dependency: python3. High-frequency surface → the lookup is BOUNDED
+# (conversation_id→gid file cache + a wall-clock scan timeout + duplicate
+# early-exit) so it never full-scans 300+ records on every render.
+set -euo pipefail
+
+input=$(cat)
+# NEVER error out — agy renders this every turn; a broken exit would put a broken
+# line in front of GLG on every prompt. python3 gone → quiet minimal line; parser
+# dies → `|| true` keeps the shell alive. doctor/smoke are the fail-LOUD surfaces.
+if ! command -v python3 >/dev/null 2>&1; then
+  device="$(cat "$HOME/.current-device" 2>/dev/null || echo UNKNOWN)"
+  printf '%s ?\n🪛 ? agy' "$device"
+  exit 0
+fi
+STATUSLINE_INPUT="$input" python3 - <<'PY' || true
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+RESET = "\033[0m"
+DIM = "\033[2m"
+CYAN_BOLD = "\033[1;36m"
+GREEN = "\033[32m"
+YELLOW = "\033[33m"
+RED_BOLD = "\033[31;1m"
+
+# Bounded-lookup knobs. The cache keys on conversation_id (stable per session) so
+# the common case (same conversation, every turn) never re-scans. The wall clock
+# caps a cache-miss scan; overrun degrades to an honest "?" rather than a stall.
+CACHE_TTL_S = 30.0
+SCAN_BUDGET_S = 0.4
+
+
+def load_input() -> dict[str, Any]:
+    raw = os.environ.get("STATUSLINE_INPUT", "")
+    try:
+        data = json.loads(raw) if raw.strip() else {}
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def dig(obj: Any, *keys: str) -> Any:
+    cur = obj
+    for key in keys:
+        if not isinstance(cur, dict):
+            return None
+        cur = cur.get(key)
+    return cur
+
+
+def device_label() -> str:
+    try:
+        text = Path.home().joinpath(".current-device").read_text(encoding="utf-8").strip()
+        return text or "UNKNOWN"
+    except Exception:
+        return "UNKNOWN"
+
+
+def shorten_home(path_text: str) -> str:
+    home = str(Path.home())
+    if path_text == home:
+        return "~"
+    if path_text.startswith(home + os.sep):
+        return "~" + path_text[len(home) :]
+    return path_text
+
+
+def split_cwd(cwd: str) -> tuple[str, str]:
+    if "/" in cwd:
+        return cwd.rsplit("/", 1)[0] + "/", cwd.rsplit("/", 1)[1]
+    return "", cwd
+
+
+def model_short(model_id: str) -> str:
+    # agy ships Gemini; keep the single-letter cadence of the cc renderer.
+    low = model_id.lower()
+    if "gemini" in low:
+        return "g"
+    return "?"
+
+
+def git_branch(cwd: str) -> str:
+    real_cwd = os.path.abspath(os.path.expanduser(cwd)) if cwd else os.getcwd()
+    try:
+        subprocess.run(["git", "rev-parse", "--git-dir"], cwd=real_cwd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        result = subprocess.run(["git", "branch", "--show-current"], cwd=real_cwd, text=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, check=False)
+        branch = result.stdout.strip()
+        return f" [{branch}]" if branch else ""
+    except Exception:
+        return ""
+
+
+def human_tokens(n: int) -> str:
+    return f"{n / 1000:.1f}K" if n >= 1000 else str(n)
+
+
+def limit_label(n: int) -> str:
+    return f"{n / 1000000:.0f}M" if n >= 1000000 else f"{n / 1000:.0f}K"
+
+
+def context_info(data: dict[str, Any]) -> str:
+    # agy's context_window carries flat totals (total_input_tokens/…) and a
+    # possibly-null current_usage — distinct from cc's current_usage.* sub-object.
+    ctx = data.get("context_window")
+    if not isinstance(ctx, dict):
+        return ""
+    try:
+        limit = int(ctx.get("context_window_size") or 0)
+        pct = int(float(ctx.get("used_percentage") or 0))
+        current = int(ctx.get("total_input_tokens") or 0) + int(ctx.get("total_output_tokens") or 0)
+    except Exception:
+        return ""
+    if limit <= 0:
+        return ""
+    color = RED_BOLD if pct >= 85 else YELLOW if pct >= 70 else GREEN
+    return f" | {color}{human_tokens(current)}/{limit_label(limit)} {pct}%{RESET}{DIM}"
+
+
+def meta_sessions_dir() -> Path:
+    override = os.environ.get("ENTWURF_META_SESSIONS_DIR")
+    if override:
+        return Path(override).expanduser().resolve()
+    agent = os.environ.get("PI_CODING_AGENT_DIR")
+    if agent:
+        return Path(agent).expanduser().resolve() / "meta-sessions"
+    return Path.home() / ".pi" / "agent" / "meta-sessions"
+
+
+def cache_path() -> Path:
+    root = os.environ.get("XDG_CACHE_HOME") or str(Path.home() / ".cache")
+    return Path(root).expanduser() / "entwurf" / "agy-statusline-gid.json"
+
+
+def cache_get(native_id: str) -> str | None:
+    try:
+        rec = json.loads(cache_path().read_text(encoding="utf-8"))
+    except Exception:
+        return None
+    if not isinstance(rec, dict):
+        return None
+    if rec.get("nativeId") != native_id:
+        return None
+    ts = rec.get("ts")
+    if not isinstance(ts, (int, float)) or (time.time() - ts) > CACHE_TTL_S:
+        return None
+    gid = rec.get("gid")
+    return gid if isinstance(gid, str) else None
+
+
+def cache_put(native_id: str, gid: str) -> None:
+    try:
+        p = cache_path()
+        p.parent.mkdir(parents=True, exist_ok=True)
+        tmp = p.with_suffix(f".tmp-{os.getpid()}")
+        tmp.write_text(json.dumps({"nativeId": native_id, "gid": gid, "ts": time.time()}), encoding="utf-8")
+        tmp.replace(p)
+    except Exception:
+        pass  # cache is best-effort; a write failure must never break the line
+
+
+def scan_gid(native_id: str) -> str:
+    # BOUNDED scan: newest records first (an agy conversation is freshly
+    # registered), duplicate early-exit, and a wall-clock budget. Overrun → "?".
+    root = meta_sessions_dir()
+    if not root.exists():
+        return "?"
+    try:
+        entries = sorted(root.glob("*.meta.json"), key=lambda f: f.stat().st_mtime, reverse=True)
+    except Exception:
+        return "?"
+    deadline = time.monotonic() + SCAN_BUDGET_S
+    matches: list[str] = []
+    for file in entries:
+        if time.monotonic() > deadline:
+            return "?"  # honest degrade, never a stall or an invented gid
+        try:
+            record = json.loads(file.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        if isinstance(record, dict) and record.get("nativeSessionId") == native_id:
+            garden = record.get("gardenId")
+            matches.append(garden if isinstance(garden, str) and garden else "!")
+            if len(matches) > 1:
+                return "!"  # duplicate fail-fast (also caps the scan)
+    if len(matches) == 1:
+        return matches[0]
+    return "?"
+
+
+def garden_lookup(native_id: str) -> str:
+    if not native_id:
+        return "ready"
+    cached = cache_get(native_id)
+    if cached is not None:
+        return cached
+    gid = scan_gid(native_id)
+    # Only memoize a settled, unambiguous answer — never cache a "?"/"!"/"ready"
+    # so a still-registering conversation is re-checked next turn.
+    if gid not in ("?", "!", "ready"):
+        cache_put(native_id, gid)
+    return gid
+
+
+def main() -> None:
+    data = load_input()
+    raw_cwd = dig(data, "workspace", "current_dir") or data.get("cwd") or "?"
+    cwd = shorten_home(str(raw_cwd))
+    cwd_dir, cwd_tail = split_cwd(cwd)
+
+    model_id = dig(data, "model", "display_name") or dig(data, "model", "id") or "?"
+    model = model_short(str(model_id))
+    vterm = "v" if os.environ.get("INSIDE_EMACS") == "vterm" else ""
+
+    # agy gives both conversation_id and session_id (same value); prefer the
+    # canonical conversation_id, fall back to session_id.
+    native_id = data.get("conversation_id") or data.get("session_id")
+    garden = garden_lookup(native_id if isinstance(native_id, str) else "")
+    line1 = (
+        f"{DIM}{device_label()} {cwd_dir}{RESET}"
+        f"{CYAN_BOLD}{cwd_tail}{RESET}"
+        f"{DIM}{git_branch(str(raw_cwd))}{RESET}"
+    )
+    line2 = f"{DIM}🪛 {garden} agy | {model}{vterm}{context_info(data)}{RESET}"
+    sys.stdout.write(f"{line1}\n{line2}")
+
+
+if __name__ == "__main__":
+    main()
+PY

package/scripts/build-bridge.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+#
+# Raw entwurf-bridge dist emit (the inner half of the `build-bridge` npm script).
+# `rm -rf` the dist dir then tsc-emit into it. Serialization against concurrent
+# packs/builds is NOT done here — it is the caller's job via scripts/with-dist-lock.sh
+# (package.json wraps this: `with-dist-lock.sh build-bridge.sh`). Keeping the emit
+# lock-free here is deliberate: the vulnerable window is the WHOLE `npm pack`
+# (prepack build + npm's post-build dist read), not just this emit, so the lock has
+# to wrap the pack, not this script — see with-dist-lock.sh for the full rationale.
+set -euo pipefail
+
+REPO_DIR=$(cd -P -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)
+
+rm -rf "$REPO_DIR/mcp/entwurf-bridge/dist"
+
+# Prefer the repo-local tsc (present under both pnpm and npm layouts); fall back to
+# a PATH tsc for a bare invocation outside the npm lifecycle.
+TSC="$REPO_DIR/node_modules/.bin/tsc"
+[ -x "$TSC" ] || TSC=tsc
+"$TSC" -p "$REPO_DIR/mcp/entwurf-bridge/tsconfig.build.json"