@rbbtsn0w/adg 0.3.0-beta.1 → 0.3.0-beta.2

package/dist/bin/adg.js

@@ -49,7 +49,7 @@ const FLAGS = {
     dir: { type: "string", short: "d", hint: "<dir>", help: "install into an explicit directory" },
     global: { type: "boolean", short: "g", help: "use ~/.agents/plugins (across all projects)" },
     project: { type: "boolean", help: "use <repo>/.agents/plugins (default)" },
-    target: { type: "string", short: "t", hint: "claude|codex|all", help: "runtime(s) to adapt for" },
+    target: { type: "string", short: "t", hint: "claude|codex|antigravity|all", help: "runtime(s) to adapt for" },
     all: { type: "boolean", short: "a", help: "select all available plugins" },
     plugin: { type: "string", short: "p", multiple: true, hint: "<name>", help: "select a specific plugin (repeatable)" },
     "no-deps": { type: "boolean", short: "n", help: "don't install dependencies" },
@@ -137,7 +137,7 @@ const PLUGIN_COMMANDS = {
     },
     link: {
         summary: "link installed plugins into a runtime",
-        synopsis: "adg plugins link --target claude|codex",
+        synopsis: "adg plugins link --target claude|codex|antigravity",
         flags: ["target", ...SCOPE],
     },
     migrate: {
@@ -253,12 +253,20 @@ function reportAgents(agents, verb) {
             console.log(ui.warn(`note: \`${r.agent}\` CLI not found — run \`adg plugins link --target ${r.agent}\` after installing it.`));
     }
 }
+/** Friendly `--target` aliases mapped onto canonical adapter target ids. */
+const TARGET_ALIASES = {
+    anthropic: "claude",
+    openai: "codex",
+    agy: "antigravity",
+    gemini: "antigravity",
+};
 function resolveTargets(target) {
     if (!target || target === "all")
         return [...ADAPTER_TARGETS];
-    if (target === "claude" || target === "codex")
-        return [target];
-    fail(`invalid --target "${String(target)}" (expected claude|codex|all)`);
+    const t = TARGET_ALIASES[target] ?? target;
+    if (ADAPTER_TARGETS.includes(t))
+        return [t];
+    fail(`invalid --target "${target}" (expected ${[...ADAPTER_TARGETS, "all"].join("|")})`);
 }
 /** Parse a `--only skills,commands` list into validated component types. */
 function resolveComponents(only) {
@@ -461,9 +469,10 @@ async function runPlugins(rawVerb, rest) {
         }
         case "link": {
             const { values } = parseVerb(verb, cmd.flags, rest);
-            const target = values.target;
-            if (target !== "claude" && target !== "codex")
-                fail("plugins link requires --target claude|codex");
+            if (values.target === undefined || values.target === "all") {
+                fail(`plugins link requires a single --target (${ADAPTER_TARGETS.join("|")})`);
+            }
+            const target = resolveTargets(values.target)[0]; // validates + maps aliases (agy → antigravity); always non-empty
             const res = linkPlugins({ pluginsDir: resolveScopeDir(values), target, global: Boolean(values.global) });
             for (const a of res.actions) {
                 console.log(`${ui.ok("linked")} ${ui.name(a.name)} ${ui.meta(`[${res.target}]`)}${a.linkedTo ? ui.meta(` -> ${a.linkedTo}`) : ""}`);
@@ -584,7 +593,7 @@ Commands:
   adg plugins marketplace list [--verbose] [--global | --project | --dir <dir>]
         Group installed plugins by source. --verbose expands each plugin to its
         components (skills, agents, commands, …).
-  adg plugins marketplace upgrade [<source>] [--all] [--target claude|codex|all] [--global | --project | --dir <dir>]
+  adg plugins marketplace upgrade [<source>] [--all] [--target claude|codex|antigravity|all] [--global | --project | --dir <dir>]
         Re-fetch a source and update its installed plugins (--all also installs
         anything new it now offers). No <source> upgrades every remote source.
   adg plugins marketplace remove <source> [--force] [--global | --project | --dir <dir>]

package/dist/src/adapters/antigravity.js

@@ -0,0 +1,18 @@
+import { join } from "node:path";
+/** Projection subdirectory that holds the self-contained agy plugin root. */
+export const ANTIGRAVITY_PROJECTION_DIR = ".antigravity-plugin";
+/**
+ * Generate an Antigravity (`agy`) plugin.json from an ADG manifest.
+ *
+ * Antigravity's manifest is minimal: it reads only `name` from a `plugin.json`
+ * and discovers components by convention (sibling `skills/`, `agents/`,
+ * `commands/`, `hooks/` directories plus a `mcp_config.json`) — all resolved
+ * relative to the directory handed to `agy plugin install`, with no manifest
+ * path indirection. We therefore project a self-contained agy plugin root under
+ * `.antigravity-plugin/`: this pure transform emits its `plugin.json`, while the
+ * agent materializes the rest (mcp_config.json + symlinked component dirs), so a
+ * partial-install `selection` is not expressible for this target.
+ */
+export function toAntigravityManifest(_pluginDir, manifest, _selection) {
+    return { defaultPath: join(ANTIGRAVITY_PROJECTION_DIR, "plugin.json"), manifest: { name: manifest.name } };
+}

package/dist/src/adapters/index.js

@@ -1,21 +1,28 @@
 import { toAnthropicManifest } from "./anthropic.js";
 import { toCodexManifest } from "./openai.js";
+import { toAntigravityManifest } from "./antigravity.js";
 export const ADAPTERS = {
     claude: toAnthropicManifest,
     anthropic: toAnthropicManifest,
     codex: toCodexManifest,
     openai: toCodexManifest,
+    antigravity: toAntigravityManifest,
+    agy: toAntigravityManifest,
+    gemini: toAntigravityManifest,
 };
-export const ADAPTER_TARGETS = ["claude", "codex"];
+export const ADAPTER_TARGETS = ["claude", "codex", "antigravity"];
 /**
  * Component categories each adapter target can actually express, mirroring what
  * the adapters emit: the Claude manifest carries skills/agents/commands/hooks/mcp
  * (`toAnthropicManifest`), while Codex only consumes skills (`toCodexManifest`).
- * `apps` is emitted by neither, so it maps to no target. Used to derive which
- * agents a plugin is adaptable to from its exposed component types.
+ * Antigravity (`agy`) discovers the same superset as Claude via convention
+ * (skills/agents/commands/hooks dirs + mcp_config.json). `apps` is emitted by
+ * none, so it maps to no target. Used to derive which agents a plugin is
+ * adaptable to from its exposed component types.
  */
 export const ADAPTER_COMPONENTS = {
     claude: ["skills", "agents", "commands", "hooks", "mcp"],
     codex: ["skills"],
+    antigravity: ["skills", "agents", "commands", "hooks", "mcp"],
 };
-export { toAnthropicManifest, toCodexManifest };
+export { toAnthropicManifest, toCodexManifest, toAntigravityManifest };

package/dist/src/agents/antigravity.js

@@ -0,0 +1,185 @@
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, rmSync, statSync, symlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative } from "node:path";
+import { ensureDir, writeJson } from "../fsutil.js";
+import { readManifest } from "../manifest.js";
+import { resolveSkillEntries } from "../skills.js";
+import { isExposed } from "../components.js";
+import { installedPluginDir, lockPath } from "../paths.js";
+import { readLock } from "../lock.js";
+import { ANTIGRAVITY_PROJECTION_DIR } from "../adapters/antigravity.js";
+/**
+ * Antigravity (`agy`) agent.
+ *
+ * Antigravity discovers a plugin by convention relative to the directory handed
+ * to `agy plugin install` — `plugin.json` plus sibling `skills/`, `agents/`,
+ * `commands/`, `hooks/` dirs and a `mcp_config.json`, with no manifest path
+ * indirection. We therefore project a self-contained agy plugin root under
+ * `<store>/.antigravity-plugin/`: generated `plugin.json` + `mcp_config.json`
+ * (the ADG `mcp/.mcp.json` shape is exactly agy's, so it passes through) and
+ * *symlinks* to the real component dirs one level up, so nothing is duplicated
+ * on disk. agy follows these symlinks; where the platform forbids them (e.g.
+ * Windows without privilege) we fall back to a copy. We then drive
+ * `agy plugin install/uninstall` (which owns `~/.gemini/antigravity-cli`).
+ */
+const ID = "antigravity";
+/**
+ * Single-directory component fields: agy reads each as a sibling dir named by
+ * convention. `skills` is handled separately because it can be a path-list and
+ * supports per-skill subsetting.
+ */
+const DIR_FIELDS = ["agents", "commands", "hooks"];
+function geminiHome(env) {
+    return env.GEMINI_HOME?.trim() || join(homedir(), ".gemini");
+}
+/**
+ * agy's config/store home: `<GEMINI_HOME>/antigravity-cli` (defaulting to
+ * `~/.gemini/antigravity-cli`). Exported so the resolver itself is testable
+ * without depending on the host filesystem state.
+ */
+export function antigravityHome(env = process.env) {
+    return join(geminiHome(env), "antigravity-cli");
+}
+function available() {
+    // `--help` is rejected by `install` (it parses it as a target), so probe the
+    // plugin command group with its own `help` subcommand instead.
+    return spawnSync("agy", ["plugin", "help"], { stdio: "ignore" }).status === 0;
+}
+function run(args) {
+    const r = spawnSync("agy", args, { encoding: "utf8" });
+    const ok = r.status === 0;
+    // Surface the CLI's own diagnostics on failure instead of swallowing them.
+    if (!ok && r.stderr)
+        console.error(r.stderr.trim());
+    return { ok, out: `${r.stdout ?? ""}${r.stderr ?? ""}` };
+}
+/** Resolve a plugin's on-disk store directory and selection from the lock's provenance. */
+function pluginStore(pluginsDir, name) {
+    const entry = readLock(lockPath(pluginsDir)).plugins[name];
+    if (!entry)
+        return undefined;
+    const dir = installedPluginDir(pluginsDir, name, entry.origin);
+    return existsSync(dir) ? { dir, selection: entry.selection } : undefined;
+}
+/** First on-disk top segment of a declared component path (e.g. "./agents/" -> "agents"). */
+function componentSegment(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    if (typeof first !== "string")
+        return undefined;
+    const seg = first.replace(/^\.?[/\\]/, "").split(/[/\\]/)[0];
+    return seg || undefined;
+}
+/**
+ * Symlink `linkPath` at `absTarget` (target stored relative so the projection
+ * survives the whole plugin dir being moved), copying instead where symlinks are
+ * unavailable (e.g. Windows without privilege). Idempotent.
+ */
+function linkOrCopy(linkPath, absTarget) {
+    rmSync(linkPath, { recursive: true, force: true });
+    ensureDir(dirname(linkPath));
+    try {
+        symlinkSync(relative(dirname(linkPath), absTarget), linkPath, "dir");
+    }
+    catch {
+        cpSync(absTarget, linkPath, { recursive: true });
+    }
+}
+/**
+ * Build the agy-native projection under `<dir>/.antigravity-plugin/`: a
+ * `plugin.json` (name only), a `mcp_config.json` copied verbatim from the
+ * manifest's mcp file when present, and relative symlinks (copy fallback) to the
+ * declared component dirs named for agy's convention.
+ *
+ * An optional `selection` (the plugin's partial install) narrows what is
+ * projected: component categories outside it are dropped, and `skills` is pinned
+ * to the selected subset. `skills` is also projected per-skill into a real
+ * `skills/` dir, so a path-list spanning multiple roots is fully honored rather
+ * than collapsing to its first root. Idempotent; safe to re-run.
+ */
+export function writeAntigravityProjection(dir, selection) {
+    const manifest = readManifest(dir);
+    const stage = join(dir, ANTIGRAVITY_PROJECTION_DIR);
+    ensureDir(stage);
+    writeJson(join(stage, "plugin.json"), { name: manifest.name });
+    const mcpConfig = join(stage, "mcp_config.json");
+    rmSync(mcpConfig, { force: true });
+    if (manifest.mcp && isExposed(selection, "mcp")) {
+        const mcpFile = join(dir, manifest.mcp);
+        // The ADG mcp file shape is exactly agy's `mcp_config.json`, so copy it
+        // verbatim — preserving formatting and avoiding a parse/re-serialize round-trip.
+        if (existsSync(mcpFile))
+            cpSync(mcpFile, mcpConfig);
+    }
+    const skillsDir = join(stage, "skills");
+    rmSync(skillsDir, { recursive: true, force: true });
+    if (manifest.skills !== undefined && isExposed(selection, "skills")) {
+        const pick = selection?.skills;
+        for (const e of resolveSkillEntries(dir, manifest)) {
+            if (pick && !pick.includes(e.name))
+                continue;
+            if (!e.skillMd)
+                continue;
+            const srcSkillDir = dirname(e.skillMd);
+            if (existsSync(srcSkillDir) && statSync(srcSkillDir).isDirectory()) {
+                linkOrCopy(join(skillsDir, e.name), srcSkillDir);
+            }
+        }
+    }
+    for (const field of DIR_FIELDS) {
+        const link = join(stage, field);
+        rmSync(link, { recursive: true, force: true });
+        if (!isExposed(selection, field))
+            continue;
+        const seg = componentSegment(manifest[field]);
+        if (!seg)
+            continue;
+        const srcDir = join(dir, seg);
+        // agy reads the component by its convention name (`field`); point that at
+        // the real source dir so a non-conventional source name still resolves.
+        if (existsSync(srcDir))
+            linkOrCopy(link, srcDir);
+    }
+}
+export const antigravityAgent = {
+    id: ID,
+    displayName: "Antigravity",
+    adaptTarget: "antigravity",
+    detect: (env = process.env) => existsSync(antigravityHome(env)),
+    available,
+    activate(ctx) {
+        if (!available())
+            return { agent: ID, affected: [], skipped: true };
+        const affected = [];
+        for (const p of ctx.plugins) {
+            // Isolate each plugin: a malformed manifest or a filesystem error must not
+            // abort activation of the remaining (valid) plugins.
+            try {
+                const store = pluginStore(ctx.pluginsDir, p);
+                if (!store)
+                    continue;
+                writeAntigravityProjection(store.dir, store.selection);
+                if (run(["plugin", "install", join(store.dir, ANTIGRAVITY_PROJECTION_DIR)]).ok)
+                    affected.push(p);
+            }
+            catch (err) {
+                console.error(`failed to enable "${p}" in Antigravity:`, err);
+            }
+        }
+        return { agent: ID, affected, skipped: false };
+    },
+    deactivate(ctx) {
+        if (!available())
+            return { agent: ID, affected: [], skipped: true };
+        const affected = [];
+        for (const p of ctx.plugins) {
+            if (run(["plugin", "uninstall", p]).ok)
+                affected.push(p);
+        }
+        return { agent: ID, affected, skipped: false };
+    },
+    // `agy plugin install` re-imports the source dir, so re-running it is the refresh.
+    refresh(ctx) {
+        return antigravityAgent.activate(ctx);
+    },
+};

package/dist/src/agents/index.js

@@ -1,10 +1,12 @@
 import { registerAgent } from "./registry.js";
 import { claudeAgent } from "./claude.js";
 import { codexAgent } from "./codex.js";
+import { antigravityAgent } from "./antigravity.js";
 // Built-in agents register on import. Third-party agents can `registerAgent()`
 // their own implementation (stage 2: discover from config without core edits).
 registerAgent(claudeAgent);
 registerAgent(codexAgent);
+registerAgent(antigravityAgent);
 export * from "./types.js";
 export { registerAgent, getAgent, allAgents, detectedAgents, resolveAgents, agentsForComponents } from "./registry.js";
 export { writeClaudeCatalog } from "./claude.js";

package/dist/src/commands/install.js

@@ -6,7 +6,7 @@ import { fromNativeManifest } from "../adapters/reverse.js";
 import { adaptPlugin } from "./adapt.js";
 import { copyPluginDir, writeJson } from "../fsutil.js";
 import { folderHash } from "../hash.js";
-import { packageFilter } from "../package.js";
+import { packageFilter, PROJECTION_DIRS } from "../package.js";
 import { lockPath, marketplacePath, marketplaceSourcePath, pluginDir } from "../paths.js";
 import { readLock, upsertEntry, writeLock } from "../lock.js";
 import { ADG_MANIFEST_PATH, readManifest } from "../manifest.js";
@@ -17,7 +17,8 @@ import { sameSource, COMPONENT_TYPES } from "../types.js";
 import { pluginContents, presentComponents } from "../components.js";
 import { skillDescriptionLoader } from "../skills.js";
 import { resolveAgents } from "../agents/index.js";
-const HASH_IGNORE = [".claude-plugin", ".codex-plugin"];
+// Generated runtime projections never count toward a plugin's content hash.
+const HASH_IGNORE = PROJECTION_DIRS;
 function toPosix(p) {
     return p.split("\\").join("/");
 }

package/dist/src/commands/update.js

@@ -1,10 +1,11 @@
 import { existsSync } from "node:fs";
 import { folderHash } from "../hash.js";
-import { packageFilter } from "../package.js";
+import { packageFilter, PROJECTION_DIRS } from "../package.js";
 import { lockPath, installedPluginDir } from "../paths.js";
 import { readLock, writeLock } from "../lock.js";
 import { readManifest } from "../manifest.js";
 import { adaptPlugin } from "./adapt.js";
+import { ADAPTER_TARGETS } from "../adapters/index.js";
 import { resolveAgents } from "../agents/index.js";
 /**
  * Re-scan installed plugins in a plugins directory, refreshing each lock
@@ -29,14 +30,16 @@ export function updateLock(pluginsDir, now = new Date().toISOString(), opts = {}
             continue;
         }
         const manifest = readManifest(dir);
-        const hash = folderHash(dir, [".claude-plugin", ".codex-plugin"], packageFilter(manifest, { includeProjections: false }));
+        const hash = folderHash(dir, PROJECTION_DIRS, packageFilter(manifest, { includeProjections: false }));
         const changed = hash !== entry.folderHash || manifest.version !== entry.version;
         if (changed) {
             entry.folderHash = hash;
             entry.version = manifest.version;
             entry.updatedAt = now;
             // Regenerate runtime manifests from the updated source, honoring selection.
-            adaptPlugin(dir, ["claude", "codex"], entry.selection);
+            // Covers every registered adapter target (claude/codex/antigravity) so a
+            // projection can't go stale after an update.
+            adaptPlugin(dir, [...ADAPTER_TARGETS], entry.selection);
             changedNames.push(name);
         }
         results.push({ name, changed, version: manifest.version, folderHash: hash });

package/dist/src/package.js

@@ -11,7 +11,7 @@
 /** Top-level metadata files always shipped with a plugin, matched case-insensitively. */
 const META_RE = /^(README|LICEN[CS]E|CHANGELOG|NOTICE)(\..+)?$/i;
 /** Generated runtime projections — shipped, but excluded from the content hash. */
-export const PROJECTION_DIRS = [".claude-plugin", ".codex-plugin"];
+export const PROJECTION_DIRS = [".claude-plugin", ".codex-plugin", ".antigravity-plugin"];
 /** Extract the first path segment of a manifest component value (e.g. "./skills/" -> "skills"). */
 function topSegment(p) {
     return p.replace(/^\.?[/\\]/, "").split(/[/\\]/)[0] ?? "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rbbtsn0w/adg",
-  "version": "0.3.0-beta.1",
+  "version": "0.3.0-beta.2",
   "description": "Agent Directory Group (ADG) toolkit — two domains: plugins and skills.",
   "type": "module",
   "license": "MIT",