Antigravity Marketplace Plugin Implementation Plan¶

#!/usr/bin/env bash
# Check the Antigravity Marketplace logo: a square RGBA PNG at least 128x128
# (the Marketplace minimum), at the path the manifest names. When rsvg-convert
# is available, also check the committed PNG matches a fresh render, so the
# asset can't drift from scripts/render-antigravity-logo.sh.
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
LOGO="$REPO_ROOT/assets/antigravity-logo.png"

fail() { echo "FAIL: $*" >&2; exit 1; }

echo "test-logo: checking Antigravity logo"

[ -f "$LOGO" ] || fail "logo missing at $LOGO"

python3 - "$LOGO" <<'PY'
import struct
import sys

data = open(sys.argv[1], "rb").read()
if data[:8] != b"\x89PNG\r\n\x1a\n":
    raise SystemExit("FAIL: logo is not a PNG")
width, height, bit_depth, color_type = struct.unpack(">IIBB", data[16:26])
if width != height:
    raise SystemExit(f"FAIL: logo is not square ({width}x{height})")
if width < 128:
    raise SystemExit(f"FAIL: logo is smaller than 128x128 ({width}x{height})")
if color_type != 6:
    raise SystemExit(f"FAIL: logo is not RGBA (PNG color type {color_type})")
PY

if command -v rsvg-convert >/dev/null 2>&1; then
  tmp="$(mktemp -d)"
  trap 'rm -f "$tmp/logo.png"; rmdir "$tmp"' EXIT
  bash "$REPO_ROOT/scripts/render-antigravity-logo.sh" --output "$tmp/logo.png" >/dev/null
  cmp -s "$tmp/logo.png" "$LOGO" \
    || fail "assets/antigravity-logo.png is stale; run scripts/render-antigravity-logo.sh"
else
  echo "SKIP: rsvg-convert not on PATH; not checking logo freshness"
fi

echo "PASS: Antigravity logo valid"

#!/usr/bin/env bash
#
# Render the Antigravity Marketplace logo from assets/superpowers-small.svg.
#
# Usage:
#   scripts/render-antigravity-logo.sh [--output PATH]
#
# Draws the Superpowers mark in near-black on a white rounded square with
# transparent corners, 512x512 PNG. Run it whenever superpowers-small.svg
# changes; tests/antigravity/test-logo.sh fails if the committed PNG is stale.
# Requires rsvg-convert (Homebrew: librsvg).
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
SOURCE_SVG="$REPO_ROOT/assets/superpowers-small.svg"
OUTPUT="$REPO_ROOT/assets/antigravity-logo.png"

usage() {
  sed -n '2,11p' "$0" | sed 's/^# \{0,1\}//'
}

die() {
  echo "error: $*" >&2
  exit 1
}

while [[ $# -gt 0 ]]; do
  case "$1" in
    --output)
      [[ $# -ge 2 ]] || die "--output needs a path"
      OUTPUT="$2"
      shift 2
      ;;
    -h | --help)
      usage
      exit 0
      ;;
    *)
      usage >&2
      die "unknown argument: $1"
      ;;
  esac
done

command -v rsvg-convert >/dev/null 2>&1 \
  || die "rsvg-convert is not on PATH (install librsvg, e.g. 'brew install librsvg')"
[[ -r "$SOURCE_SVG" ]] || die "source mark not readable: $SOURCE_SVG"

# Everything inside the source <svg> element: the mark's paths and ellipse.
mark="$(sed -E 's/^.*<svg[^>]*>//; s#</svg>.*$##' "$SOURCE_SVG")"
[[ -n "$mark" ]] || die "could not extract the mark from $SOURCE_SVG"

# The mark's bounding box is centered at (256,256) in its 512 viewBox and is
# 348 units wide; scale 0.905 makes it ~70% of the 450-unit rounded square.
composed="$(mktemp)"
trap 'rm -f "$composed"' EXIT
cat >"$composed" <<EOF
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
  <rect x="31" y="31" width="450" height="450" rx="100" ry="100" fill="#ffffff"/>
  <g fill="#1a1a1a" transform="translate(256 256) scale(0.905) translate(-256 -256)">$mark</g>
</svg>
EOF

rsvg-convert -w 512 -h 512 "$composed" -o "$OUTPUT"
echo "wrote $OUTPUT"

git add scripts/render-antigravity-logo.sh assets/antigravity-logo.png tests/antigravity/test-logo.sh
git commit -m "feat(antigravity): render Marketplace logo from the Superpowers mark"

#!/usr/bin/env bash
# Validate the native Antigravity plugin: the Marketplace manifest, the
# always-on rule that bootstraps using-superpowers, and the repo layout agy
# depends on. CI-safe; when `agy` is on PATH, also runs `agy plugin validate`.
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"

echo "test-plugin-manifest: checking Antigravity plugin"

python3 - "$REPO_ROOT" <<'PY'
import json
import re
import struct
import sys
from pathlib import Path

root = Path(sys.argv[1])

def fail(message):
    raise SystemExit(f"FAIL: {message}")

manifest_path = root / ".antigravity-plugin" / "plugin.json"
if not manifest_path.is_file():
    fail(f"manifest missing at {manifest_path}")
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))

# --- Marketplace-required fields -------------------------------------------
for field in ["name", "description", "displayName", "logo",
              "suggestedPrompts", "version", "author"]:
    if not manifest.get(field):
        fail(f"manifest field {field!r} is missing or empty")

if manifest["name"] != "superpowers":
    fail(f"name must be 'superpowers', got {manifest['name']!r}")
if not re.fullmatch(r"[a-z0-9]+(-[a-z0-9]+)*", manifest["name"]):
    fail("name is not kebab-case")

description_length = len(manifest["description"])
if not 120 <= description_length <= 160:
    fail(f"description is {description_length} characters; Marketplace wants 120-160")

prompts = manifest["suggestedPrompts"]
if not isinstance(prompts, list) or not 1 <= len(prompts) <= 3:
    fail("suggestedPrompts must be a list of 1-3 prompts")
if not all(isinstance(p, str) and p.strip() for p in prompts):
    fail("suggestedPrompts entries must be non-empty strings")

claude_manifest = json.loads(
    (root / ".claude-plugin" / "plugin.json").read_text(encoding="utf-8"))
if manifest["version"] != claude_manifest["version"]:
    fail(f"version {manifest['version']!r} != .claude-plugin version "
         f"{claude_manifest['version']!r}")
if manifest["author"] != claude_manifest["author"]:
    fail("author does not match .claude-plugin/plugin.json")

# --- Logo ------------------------------------------------------------------
logo = root / manifest["logo"]
if not logo.is_file():
    fail(f"logo {manifest['logo']!r} does not exist")
header = logo.read_bytes()[:26]
if header[:8] != b"\x89PNG\r\n\x1a\n":
    fail("logo is not a PNG")
width, height = struct.unpack(">II", header[16:24])
if width != height or width < 128:
    fail(f"logo must be square and at least 128x128, got {width}x{height}")

# --- Version bumps ---------------------------------------------------------
version_config = json.loads((root / ".version-bump.json").read_text(encoding="utf-8"))
if not any(entry.get("path") == ".antigravity-plugin/plugin.json"
           and entry.get("field") == "version"
           for entry in version_config.get("files", [])):
    fail(".version-bump.json does not register .antigravity-plugin/plugin.json")

# --- Bootstrap rule: @-pointers only, each resolving from rules/ -----------
rule = root / "rules" / "AGENTS.md"
if not rule.is_file():
    fail(f"bootstrap rule missing at {rule}")
lines = [line.strip() for line in rule.read_text(encoding="utf-8").splitlines()
         if line.strip()]
if not lines:
    fail("bootstrap rule is empty")
for line in lines:
    if not line.startswith("@"):
        fail(f"bootstrap rule must contain only @-pointers, found: {line!r}")
    target = (rule.parent / line[1:]).resolve()
    if not target.is_file():
        fail(f"rule pointer {line!r} does not resolve from rules/ to a file")
if not any(line.endswith("skills/using-superpowers/SKILL.md") for line in lines):
    fail("bootstrap rule does not point at using-superpowers")

# --- Layout agy depends on -------------------------------------------------
for stray in ["plugin.json", "hooks.json"]:
    if (root / stray).exists():
        fail(f"root {stray} must not exist; agy would read it instead")
PY

if command -v agy >/dev/null 2>&1; then
  output="$(agy plugin validate "$REPO_ROOT" 2>&1)" \
    || { echo "$output" >&2; echo "FAIL: agy plugin validate failed" >&2; exit 1; }
  grep -q '\[ok\]' <<<"$output" \
    || { echo "$output" >&2; echo "FAIL: agy plugin validate did not report [ok]" >&2; exit 1; }
  grep -qE 'skills +: [0-9]+ processed' <<<"$output" \
    || { echo "$output" >&2; echo "FAIL: agy found no skills" >&2; exit 1; }
else
  echo "SKIP: agy not on PATH; not running agy plugin validate"
fi

echo "PASS: Antigravity plugin manifest and bootstrap rule valid"

{
  "name": "superpowers",
  "displayName": "Superpowers",
  "version": "6.4.2",
  "description": "Skills that make your coding agent work like a senior engineer: brainstorming, planning, test-driven development, systematic debugging, and code review.",
  "logo": "assets/antigravity-logo.png",
  "suggestedPrompts": [
    "Let's brainstorm a new feature before writing any code",
    "Help me systematically debug a failing test",
    "Write an implementation plan for this change"
  ],
  "category": "Developer Tools",
  "keywords": [
    "skills",
    "tdd",
    "debugging",
    "collaboration",
    "best-practices",
    "workflows"
  ],
  "author": {
    "name": "Jesse Vincent",
    "email": "jesse@fsck.com"
  },
  "homepage": "https://github.com/obra/superpowers",
  "repository": "https://github.com/obra/superpowers",
  "license": "MIT"
}

@../skills/using-superpowers/SKILL.md

    { "path": ".antigravity-plugin/plugin.json", "field": "version" },

git add .antigravity-plugin/plugin.json rules/AGENTS.md .version-bump.json tests/antigravity/test-plugin-manifest.sh
git commit -m "feat(antigravity): native plugin manifest with always-on bootstrap rule"

    cat > "$repo/.antigravity-plugin/plugin.json" <<EOF
{
  "name": "superpowers",
  "version": "$MANIFEST_VERSION"
}
EOF

    printf '@../skills/using-superpowers/SKILL.md\n' > "$repo/rules/AGENTS.md"
    printf 'antigravity png fixture\n' > "$repo/assets/antigravity-logo.png"

        .antigravity-plugin/plugin.json \
        rules/AGENTS.md \
        assets/antigravity-logo.png \

    assert_not_contains "$preview_section" ".antigravity-plugin/plugin.json" "Preview excludes Antigravity manifest from Codex sync"
    assert_not_contains "$preview_section" "rules/AGENTS.md" "Preview excludes Antigravity bootstrap rule from Codex sync"
    assert_not_contains "$preview_section" "assets/antigravity-logo.png" "Preview excludes Antigravity logo from Codex sync"

  "/.antigravity-plugin/"

  "/rules/"

  # Other harnesses' assets
  "/assets/antigravity-logo.png"

git add scripts/sync-to-codex-plugin.sh tests/codex-plugin-sync/test-sync-to-codex-plugin.sh
git commit -m "fix(codex-sync): exclude Antigravity manifest, rule, and logo"

Install Superpowers as a plugin from this repository:

```bash
agy plugin install https://github.com/obra/superpowers
```

The plugin ships an always-on rule that loads the `using-superpowers` skill, so
Superpowers is active from the first message. Reinstall with the same command to
update.

# Validate the Antigravity (agy) integration. agy installs the existing plugin
# directly (`agy plugin install <repo-url>`): it loads the bundled skills and
# runs the SessionStart hook for bootstrap, so there is no agy-specific scaffold
# to test. What IS agy-specific is the tool mapping — subagent dispatch via
# invoke_subagent (self/research types) and task tracking via a task artifact —
# and SKILL.md pointing at it.

# Validate the Antigravity (agy) tool mapping: subagent dispatch via
# invoke_subagent (self/research types), task tracking via a task artifact, and
# SKILL.md pointing at the mapping. The plugin manifest and bootstrap rule are
# checked by test-plugin-manifest.sh.

git add README.md tests/antigravity/test-antigravity-tools.sh
git commit -m "docs(antigravity): describe the always-on rule bootstrap"

mkdir -p "$SCRATCH/accept/superpowers"
git archive HEAD | tar -x -C "$SCRATCH/accept/superpowers"
agy plugin install "$SCRATCH/accept/superpowers"
agy plugin list

mkdir -p "$SCRATCH/accept/ws$n"
cd "$SCRATCH/accept/ws$n"
agy -p "Let's make a react todo list" --output-format stream-json --print-timeout 240s > out.jsonl 2> err.txt

python3 -I -c "
import json
for l in open('out.jsonl'):
  e=json.loads(l); s=e.get('step_update') or {}
  if s.get('state') in ('DONE','ERROR'):
    p=(s.get('tool_info') or {}).get('parameters') or {}
    print(s.get('step_index'), s.get('tool_name'), str(p.get('AbsolutePath') or p.get('TargetFile') or p.get('CommandLine') or '')[-90:])
  if e.get('event')=='result': print('RESULT:', e['result'].get('response','')[:600])
"

agy plugin uninstall superpowers
agy plugin list

| has a plugin install command and a manifest `contextFileName` (or equivalent) the installer keeps | C via the plugin installer | Antigravity (`.antigravity-plugin/` — `agy plugin install` ships a generated context file; verify the installer preserves it — Part 6) |

| loads always-on rule files shipped inside a plugin | C via a plugin rule | Antigravity (`.antigravity-plugin/plugin.json` + `rules/AGENTS.md`, a one-line `@` pointer to `using-superpowers` — Part 6) |

   **For the bootstrap itself, prefer something the harness loads every
   session (Part 6).** That's a declared context file where the manifest has a
   `contextFileName`-style field, or an always-on rule where the plugin format
   has rules. Antigravity uses a rule: `rules/AGENTS.md` holds one line,
   `@../skills/using-superpowers/SKILL.md`. agy rewrites a rule-relative `@`
   path to the absolute install path but does not inline the file; the model
   reads it with `view_file`. agy does not substitute `${PLUGIN_ROOT}` in rules.
   Point at `using-superpowers`; never copy it into the rule.

| Local installer (plugin install) | Antigravity (`agy`) | A small `install.sh` that runs the harness's own `agy plugin install` against a staging dir holding the manifest, the skills, and a generated `contextFileName` context file (the bootstrap). Everything arrives through the install mechanism — *not* by editing the user's config (see below). |

| Git-URL plugin install + marketplace | Antigravity (`agy`) | Users run `agy plugin install https://github.com/obra/superpowers`. agy reads `.antigravity-plugin/plugin.json`, whose Marketplace fields (`displayName`, `logo`, `suggestedPrompts`, `version`, `author`) also drive the Antigravity Marketplace listing. Without that manifest, agy falls back to importing `gemini-extension.json`. |

    **Verify with a marker** that the installer keeps the file and the
    harness loads it: a file the manifest doesn't declare can be stripped as
    unrecognized.

  - **Or ship an always-on rule, if the plugin format has rules.** Antigravity
    loads `rules/AGENTS.md` from an installed plugin every session; a one-line
    `@` pointer there bootstraps `using-superpowers`. Run a marker test to
    confirm what the harness does with `@` paths in rules — agy rewrites them
    to absolute paths without inlining them.

| Antigravity (`agy`) | `.antigravity-plugin/plugin.json` + `rules/AGENTS.md` | always-on plugin rule `@`-points at `using-superpowers` (no session-start hook event exists) | `references/antigravity-tools.md` | `tests/antigravity/` | `agy plugin install` git URL; Antigravity Marketplace |

git add docs/porting-to-a-new-harness.md
git commit -m "docs(porting): describe Antigravity's rule bootstrap, drop phantom installer"