@raymondchins/agentmap 0.7.0 → 0.8.0

package/README.md

@@ -185,23 +185,41 @@ internally on `tool_name`. For reference, or to wire it by hand:
 That's the "forced to use it" in the tagline: the map stays current on its own, and the
 agent is steered to it the moment it reaches for a dependency-shaped grep or Bash search.
 
-### 3. Agent skills (Cursor, Claude Code, Codex)
+### 3. Agent skills (Cursor, Claude Code, Codex, OpenCode, Gemini, Antigravity, Copilot)
 
 ```bash
 npx @raymondchins/agentmap --install-skill
 ```
 
-Copies a packaged **SKILL.md** (Claude Code / Codex / OpenCode) and a **Cursor rule**
-(`.cursor/rules/agentmap.mdc`, `alwaysApply: true`) into the current repo or global
-agent directories. Options:
+Copies packaged **SKILL.md** files and a **Cursor rule** (`.cursor/rules/agentmap.mdc`,
+`alwaysApply: true`) into the current repo or global agent directories. Paths follow
+each platform's official skill-directory conventions. Options:
 
 ```bash
-agentmap --install-skill --platform cursor      # Cursor rule only
-agentmap --install-skill --platform claude      # .claude/skills/agentmap/SKILL.md
+agentmap --install-skill --platform cursor           # Cursor rule only (project)
+agentmap --install-skill --platform claude           # .claude/skills/agentmap/SKILL.md
+agentmap --install-skill --platform codex            # .codex/skills/ (project) or ~/.codex/skills/ (global)
+agentmap --install-skill --platform opencode         # .opencode/skills/ (project) or ~/.config/opencode/skills/ (global)
+agentmap --install-skill --platform gemini           # .gemini/skills/ (project); global ~/.gemini/skills/ (Windows global: ~/.agents/skills/)
+agentmap --install-skill --platform antigravity      # .agents/skills/ (project) or ~/.gemini/config/skills/ (global)
+agentmap --install-skill --platform copilot          # .copilot/skills/ or ~/.copilot/skills/
 agentmap --install-skill --global --platform claude  # ~/.claude/skills/...
-agentmap --install-skill --dry-run              # preview paths, no writes
+agentmap --install-skill --platform agents           # legacy .agents/skills/ (project or global); excluded from default `all`
+agentmap --install-skill --dry-run                   # preview paths, no writes
 ```
 
+`--platform all` installs: claude, cursor, codex, opencode, gemini, antigravity, copilot (not legacy `agents`).
+
+Some platforms also get **always-on** docs and hooks in the same command:
+
+| `--platform` | Skill | Also installs (project) | Global docs |
+|--------------|-------|-------------------------|-------------|
+| `gemini` | `.gemini/skills/…/SKILL.md` | `GEMINI.md` + `.gemini/settings.json` BeforeTool nudge | `~/.gemini/GEMINI.md` |
+| `codex` | `.codex/skills/…/SKILL.md` | `AGENTS.md` merge-safe `<!-- agentmap:begin/end -->` block | `~/.codex/AGENTS.md` |
+| `opencode` | `.opencode/skills/…/SKILL.md` | `AGENTS.md` + `.opencode/plugins/agentmap-nudge.js` | `~/.config/opencode/AGENTS.md` |
+
+Codex and OpenCode share one repo-root `AGENTS.md` on project install. Existing content outside the marked block is preserved.
+
 Pair with `--install-hooks` (Claude Code) or `--mcp` (Cursor MCP).
 
 ---
@@ -501,7 +519,7 @@ $ node agentmap.mjs --print | jq '.hubs[0]'
 | `--json` | **Global modifier.** When present, every command prints exactly one JSON object to stdout (no prose). Shapes vary per command: `--json --hubs` → `{command,fileCount,sha,hubs:[string]}`, `--json --find X` → `{command,query,matches:[{file,name,kind}]}`, `--json --relates X` → `{command,file,pagerank,exports,imports,dependents,related}`, `--json --any X` → `{command,query,kind,…payload}`, etc. Bare `--json` (no query flag) → `{command:"build",fileCount,features,topHub}`. |
 | `--install-hooks` | Copy `hooks/post-commit` into `.git/hooks/` (chmod 0755), ensure `.claude/agentmap.json` is in `.gitignore`, and auto-wire the Claude Code `PreToolUse(Grep)` nudge into `.claude/settings.json` (merge-safe + idempotent). Exit 0 on success, stderr + exit 1 on failure. |
 | `--hook-status` | Report whether the post-commit hook, PreToolUse nudge, and `.gitignore` entry are installed (no writes). |
-| `--install-skill` | Install packaged agent skill + Cursor rule (`--platform claude\|cursor\|agents\|all`, default `all`; `--project` default, or `--global`; `--dry-run` preview). |
+| `--install-skill` | Install skills + always-on docs/hooks per platform (`--platform claude\|cursor\|codex\|opencode\|gemini\|antigravity\|copilot\|agents\|all`, default `all`; `--project` default, or `--global`; `--dry-run` preview). |
 | `--mcp` | Start agentmap as a **stdio MCP server** so non-Claude-Code agents (Cursor, Cline, any MCP client) can call every flag as a first-class tool. |
 
 **Exit-code contract:** `0` = success / match / help / version; `1` = query returned zero results (`--any`, `--find`, `--relates`, `--feature` with no match); `2` = usage error (missing required arg, unknown flag). Any token starting with `-` that matches no known flag prints an error to stderr and exits 2.

package/agentmap.mjs

@@ -281,6 +281,77 @@ function identMul(ident, defineCount, mentioned) {
   return mul;
 }
 
+// Read baseUrl+paths from a tsconfig/jsconfig file. Returns null when absent.
+// Follows `extends` recursively (depth-capped) so a package tsconfig that only
+// `extends` a shared base (Turborepo tsconfig.base.json holding all `paths`)
+// still contributes its inherited baseUrl/paths. Child overrides parent.
+function readTsconfigAliasOpts(cfgPath, _depth = 0) {
+  try {
+    const raw = JSON.parse(readFileSync(cfgPath, "utf8")) || {};
+    const co = raw.compilerOptions || {};
+    // Resolve inherited opts from `extends` first (parent), then layer self on top.
+    let inherited = null;
+    if (raw.extends && _depth < 10) {
+      const exts = Array.isArray(raw.extends) ? raw.extends : [raw.extends];
+      const here = dirname(cfgPath);
+      for (const ext of exts) {
+        if (typeof ext !== "string" || !ext) continue;
+        // Only resolve path-like extends (./, ../, absolute). Bare package
+        // extends (e.g. "@tsconfig/strict") live in node_modules and don't
+        // carry repo-local `paths`, so skip them safely.
+        if (!/^(\.\.?\/|\/)/.test(ext)) continue;
+        let base = join(here, ext);
+        if (!existsSync(base) && existsSync(base + ".json")) base += ".json";
+        else if (!/\.json$/.test(base) && existsSync(join(base, "tsconfig.json"))) base = join(base, "tsconfig.json");
+        if (!existsSync(base)) continue;
+        const parent = readTsconfigAliasOpts(base, _depth + 1);
+        if (parent) inherited = { ...(inherited || {}), ...parent };
+      }
+    }
+    const self = {};
+    if (co.baseUrl) self.baseUrl = co.baseUrl;
+    if (co.paths) self.paths = co.paths;
+    const out = { ...(inherited || {}), ...self };
+    if (!Object.keys(out).length) return null;
+    return out;
+  } catch { return null; }
+}
+
+// Collect package-level alias configs from tsconfig/jsconfig files in the repo.
+// Deepest-dir-first sort so nearestAliasConfig can pick the longest prefix match.
+function discoverPackageAliasConfigs(rootAbs, listed) {
+  const root = rootAbs.replace(/\\/g, "/");
+  const configs = [];
+  const cfgRels = listed.length
+    ? listed.filter((f) => /(^|\/)tsconfig\.json$/.test(f) || /(^|\/)jsconfig\.json$/.test(f))
+    : [];
+  for (const rel of cfgRels) {
+    const full = join(root, rel);
+    if (!existsSync(full)) continue;
+    const opts = readTsconfigAliasOpts(full);
+    if (!opts) continue;
+    configs.push({
+      dir: join(root, dirname(rel)).replace(/\\/g, "/"),
+      baseUrl: opts.baseUrl || ".",
+      paths: opts.paths || {},
+    });
+  }
+  configs.sort((a, b) => b.dir.length - a.dir.length);
+  return configs;
+}
+
+// Longest matching tsconfig dir wins (monorepo package boundary).
+function nearestAliasConfig(fromAbsDir, configs, rootAbs, rootOpts) {
+  const norm = fromAbsDir.replace(/\\/g, "/");
+  let best = null;
+  for (const c of configs) {
+    const d = c.dir;
+    if (norm === d || norm.startsWith(d + "/")) { best = c; break; } // configs sorted deepest-first
+  }
+  if (best) return best;
+  return { dir: rootAbs, baseUrl: rootOpts.baseUrl || ".", paths: rootOpts.paths || {} };
+}
+
 // Construct a ts-morph Project robustly: use tsconfig.json when present + valid;
 // else (missing / malformed / solution-style references that index 0 files) fall
 // back to broad source globs so the tool degrades gracefully instead of crashing.
@@ -296,11 +367,8 @@ function makeProject() {
     for (const cfg of ["tsconfig.json", "jsconfig.json"]) {
       try {
         if (!existsSync(cfg)) continue;
-        const co = (JSON.parse(readFileSync(cfg, "utf8")) || {}).compilerOptions || {};
-        const out = {};
-        if (co.baseUrl) out.baseUrl = co.baseUrl;
-        if (co.paths) out.paths = co.paths;
-        if (Object.keys(out).length) return out;
+        const opts = readTsconfigAliasOpts(cfg);
+        if (opts) return opts;
       } catch { /* ignore — proceed without paths */ }
     }
     return {};
@@ -329,6 +397,7 @@ function makeProject() {
   const loaded = new Set(project.getSourceFiles().map((s) => s.getFilePath()));
   const cwdp = process.cwd().replace(/\\/g, "/");
   const listed = sh("git ls-files --cached --others --exclude-standard").split("\n").filter(Boolean);
+  const packageAliasConfigs = discoverPackageAliasConfigs(cwdp, listed);
   // `.vue` discovery: same channel as TS/JS (git ls-files when available, else
   // a broad glob fallback). We do NOT hand `.vue` straight to ts-morph (it is
   // not TS/JS). Instead, for each `.vue` file we read its `<script>` block via
@@ -390,7 +459,7 @@ function makeProject() {
     vueMap[`${cwdp}/${vpath}`] = `${cwdp}/${f}`;
     vueReal[`${cwdp}/${f}`] = true;
   }
-  return { project, vueMap, vueReal, aliasOpts };
+  return { project, vueMap, vueReal, aliasOpts, packageAliasConfigs };
 }
 
 // ---------------------------------------------------------------------------
@@ -400,7 +469,7 @@ function makeProject() {
 // ---------------------------------------------------------------------------
 function build() {
   const t0 = Date.now();
-  const { project, vueMap, vueReal, aliasOpts } = makeProject();
+  const { project, vueMap, vueReal, aliasOpts, packageAliasConfigs } = makeProject();
   const { SyntaxKind } = tsMorph();
   const CallExpression = SyntaxKind.CallExpression;
   const cwd = process.cwd().replace(/\\/g, "/");
@@ -439,14 +508,15 @@ function build() {
     if (vueReal[`${abs}.vue`]) return rel(`${abs}.vue`);
     return null;
   };
-  // #3 fix: tsconfig/jsconfig baseUrl+paths alias resolution ("@/x", "~/x") for
-  // the side-effect/dynamic/require edges too. Static imports already resolve via
-  // ts-morph's getModuleSpecifierSourceFile(); without this, `import "@/lib/x"`,
-  // `import("@/lib/x")` and `require("@/lib/x")` silently formed NO edge.
+  // #3 fix + monorepo: tsconfig/jsconfig baseUrl+paths alias resolution ("@/x",
+  // "#/x", "~/x") for side-effect/dynamic/require edges AND static imports when
+  // ts-morph can't resolve (cwd tsconfig lacks package paths). Per importing
+  // file, use the nearest discovered tsconfig paths.
   const ROOTABS = process.cwd().replace(/\\/g, "/");
-  const aliasBase = aliasOpts.baseUrl ? joinPosix(ROOTABS, aliasOpts.baseUrl) : ROOTABS;
-  const aliasEntries = Object.entries(aliasOpts.paths || {});
-  const resolveAlias = (spec) => {
+  const resolveAlias = (spec, fromAbsDir) => {
+    const cfg = nearestAliasConfig(fromAbsDir, packageAliasConfigs, ROOTABS, aliasOpts);
+    const aliasBase = joinPosix(cfg.dir, cfg.baseUrl || ".");
+    const aliasEntries = Object.entries(cfg.paths || {});
     for (const [pat, targets] of aliasEntries) {
       const star = pat.indexOf("*");
       let sub = null;
@@ -466,7 +536,7 @@ function build() {
     return null;
   };
   const resolveSpec = (fromAbsDir, spec) => {
-    if (!spec.startsWith(".")) return resolveAlias(spec); // alias (baseUrl/paths) or null for non-relative
+    if (!spec.startsWith(".")) return resolveAlias(spec, fromAbsDir); // alias (baseUrl/paths) or null for non-relative
     // normalize fromAbsDir + spec into an absolute-ish posix path
     const join = (a, b) => {
       const parts = (a + "/" + b).split("/"); const st = [];
@@ -524,11 +594,16 @@ function build() {
         if (imp.getNamespaceImport()) names.push("*");
         addEdge(rel(t.getFilePath()), names.length ? names : ["*"]);
       } else {
-        // 6b: side-effect import (`import "./x"`) — no source file via ts-morph,
-        // but a relative specifier resolving in-project still counts as an edge.
+        // 6b: side-effect or alias import — ts-morph may not resolve when cwd
+        // tsconfig lacks package paths; resolveSpec uses nearest tsconfig paths.
         const spec = imp.getModuleSpecifierValue();
         const tp = resolveSpec(fromDir, spec);
-        if (tp) addEdge(tp, ["*"]);
+        if (tp) {
+          const names = imp.getNamedImports().filter((n) => !n.isTypeOnly()).map((n) => n.getName());
+          if (imp.getDefaultImport()) names.push("default");
+          if (imp.getNamespaceImport()) names.push("*");
+          addEdge(tp, names.length ? names : ["*"]);
+        }
       }
     }
     for (const exp of sf.getExportDeclarations()) {
@@ -1090,8 +1165,8 @@ Maintenance:
   --install-hooks [--dry-run]
                        install git post-commit + copy the PreToolUse nudge +
                        wire .claude/settings.json (--dry-run = preview, no writes)
-  --install-skill [--platform claude|cursor|agents|all] [--project|--global] [--dry-run]
-                       install SKILL.md / Cursor rule for coding agents
+  --install-skill [--platform claude|cursor|codex|opencode|gemini|antigravity|copilot|agents|all] [--project|--global] [--dry-run]
+                       install skills + always-on docs/hooks per platform
   --hook-status          report whether agentmap git/nudge wiring is installed
   --setup-mcp [--dry-run]
                        configure MCP server for OpenCode & Antigravity IDE

package/hooks/agentmap-gemini-nudge.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// Gemini CLI BeforeTool nudge — non-blocking context when a search looks like
+// dependency / blast-radius / reuse work. Stdlib only; copied into the project
+// by `agentmap --install-skill --platform gemini`.
+
+let raw = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (c) => (raw += c));
+process.stdin.on("end", () => {
+  try {
+    const payload = JSON.parse(raw || "{}");
+    const tool = String(payload.tool_name || "");
+    const ti = payload.tool_input || {};
+
+    const DEP_RE =
+      /\b(import|require\s*\(|imported\s+by|depends|dependents?|dependency)\b|from\s+["']|(^|\|)\s*export\b/i;
+    const GENERIC_DENYLIST =
+      /<(Promise|Array|Map|Set|Record|Partial|Readonly|Pick|Omit|Required|Exclude|Extract|NonNullable|ReturnType|Awaited|Parameters|InstanceType)\b/;
+    const COMPONENT_TAG_RE = /<[A-Z][\w.]*/;
+    const INTENT_RE =
+      /\bwhere\s+is\b|\bwho\s+(imports|uses|renders)\b|\breuse\b|\b(existing|shared)\s+(util|component|hook|helper)\b|\bis\s+there\s+(an?\s+)?(existing|shared)\b/i;
+    const SYMBOL_RE = /\b[A-Z][a-z0-9]+[A-Z][A-Za-z0-9]*\b/;
+
+    let fire = false;
+    const pattern = String(ti.pattern || ti.query || ti.content || "");
+    const cmd = String(ti.command || ti.cmd || "");
+
+    if (/grep|search|ripgrep/i.test(tool)) {
+      if (pattern.length > 0 && pattern.length <= 2000) {
+        fire =
+          DEP_RE.test(pattern) ||
+          (COMPONENT_TAG_RE.test(pattern) && !GENERIC_DENYLIST.test(pattern)) ||
+          INTENT_RE.test(pattern);
+      }
+    } else if (/shell|bash|terminal|command/i.test(tool) && cmd) {
+      const SEARCHER_RE = /(^|[;&]\s*)(rg|ripgrep|grep|egrep|fgrep|ag|ack)\b/;
+      if (SEARCHER_RE.test(cmd)) {
+        const DATA_FILE_RE = /\.(log|txt|out|csv|tsv|jsonl|ndjson|json|md|ya?ml|xml)(\b|$)/i;
+        const hasDataFileTarget = cmd.split(/\s+/).some((tok) => DATA_FILE_RE.test(tok));
+        if (!hasDataFileTarget) {
+          fire =
+            DEP_RE.test(cmd) ||
+            (COMPONENT_TAG_RE.test(cmd) && !GENERIC_DENYLIST.test(cmd)) ||
+            INTENT_RE.test(cmd) ||
+            SYMBOL_RE.test(cmd);
+        }
+      }
+    }
+
+    if (fire) {
+      const msg =
+        "Dependency / blast-radius / reuse search detected. Prefer agentmap first: " +
+        "`npx @raymondchins/agentmap --any <query>` (file → symbol → feature → git-grep), " +
+        "`--relates <path>`, `--find <symbol>`. Rebuild with `npx @raymondchins/agentmap` if stale.";
+      process.stdout.write(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "BeforeTool",
+            additionalContext: msg,
+          },
+        }),
+      );
+    } else {
+      process.stdout.write("{}");
+    }
+  } catch {
+    process.stdout.write("{}");
+  }
+  process.exit(0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raymondchins/agentmap",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "publishConfig": {
     "access": "public"
   },

package/skills/guidance.md

@@ -0,0 +1,24 @@
+## agentmap (repo map)
+
+This project can use **agentmap** (`@raymondchins/agentmap`) — a queryable import/symbol map at `.claude/agentmap/`.
+
+**Before Grep/Glob for structural questions** (where is a symbol, who imports a file, reuse check, blast radius), prefer:
+
+```bash
+agentmap --any <query>          # file → symbol → feature → git-grep fallback
+agentmap --find <Symbol>        # exported symbols matching name
+agentmap --relates <file.ts>    # imports, dependents, related files
+agentmap --map --tokens 400     # cheap repo orientation
+```
+
+Use Read/Grep directly when:
+
+1. agentmap already oriented you and you need exact lines to edit
+2. The map is missing — run `agentmap` once to build `.claude/agentmap/`
+3. Searching raw strings, logs, or non-TS files
+
+**MCP (optional):** `agentmap --mcp` exposes the same queries as tools.
+
+**Note:** `--features` only detects Next.js `app/` routes; TanStack `src/routes/` repos often show `features (0)`.
+
+Package: `@raymondchins/agentmap` — not the unrelated PyPI/npm `agentmap` package.

package/skills/install-helpers.mjs

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT
+// Shared helpers for --install-skill (docs merge, hooks, plugins).
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SKILLS_DIR = dirname(fileURLToPath(import.meta.url));
+export const GUIDANCE = join(SKILLS_DIR, "guidance.md");
+const GEMINI_NUDGE_SRC = join(SKILLS_DIR, "..", "hooks", "agentmap-gemini-nudge.mjs");
+const OPENCODE_PLUGIN_SRC = join(SKILLS_DIR, "opencode-agentmap-nudge.js");
+
+export const MARK_BEGIN = "<!-- agentmap:begin -->";
+export const MARK_END = "<!-- agentmap:end -->";
+
+export function atomicWrite(dest, body) {
+  mkdirSync(dirname(dest), { recursive: true });
+  const tmp = `${dest}.tmp`;
+  writeFileSync(tmp, body, "utf8");
+  renameSync(tmp, dest);
+}
+
+function stripJsonComments(src) {
+  let out = "";
+  let inStr = false, esc = false, inLine = false, inBlock = false;
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i], n = src[i + 1];
+    if (inLine) { if (c === "\n") { inLine = false; out += c; } continue; }
+    if (inBlock) { if (c === "*" && n === "/") { inBlock = false; i++; } continue; }
+    if (inStr) {
+      out += c;
+      if (esc) esc = false;
+      else if (c === "\\") esc = true;
+      else if (c === '"') inStr = false;
+      continue;
+    }
+    if (c === '"') { inStr = true; out += c; continue; }
+    if (c === "/" && n === "/") { inLine = true; i++; continue; }
+    if (c === "/" && n === "*") { inBlock = true; i++; continue; }
+    out += c;
+  }
+  return out;
+}
+
+function parseSettings(text, settingsPath) {
+  try { return JSON.parse(text) || {}; }
+  catch {
+    try { return JSON.parse(stripJsonComments(text)) || {}; }
+    catch { throw new Error(`${settingsPath} is not valid JSON — fix or remove it, then re-run`); }
+  }
+}
+
+export function readGuidanceSection() {
+  if (!existsSync(GUIDANCE)) throw new Error(`packaged guidance missing: ${GUIDANCE}`);
+  return readFileSync(GUIDANCE, "utf8");
+}
+
+export function mergeGuidanceBlock(existing, section, title) {
+  const block = `${MARK_BEGIN}\n${section.trim()}\n${MARK_END}`;
+  const re = /<!-- agentmap:begin -->[\s\S]*?<!-- agentmap:end -->/;
+  if (existing && re.test(existing)) return existing.replace(re, block);
+  const header = title ? `# ${title}\n\n` : "";
+  if (!existing?.trim()) return `${header}${block}\n`;
+  return `${existing.trimEnd()}\n\n${block}\n`;
+}
+
+/** @returns {string[]} relative paths touched */
+export function installGeminiHooks(root, dryRun) {
+  if (root !== process.cwd()) return [];
+  const nudgeRel = ".gemini/hooks/agentmap-nudge.mjs";
+  const nudgeDest = join(root, nudgeRel);
+  const settingsPath = ".gemini/settings.json";
+  const NUDGE_CMD = `node "$GEMINI_PROJECT_DIR/.gemini/hooks/agentmap-nudge.mjs"`;
+  const targets = [nudgeRel, settingsPath];
+
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    settings = parseSettings(readFileSync(settingsPath, "utf8"), settingsPath);
+  }
+  settings.hooks ??= {};
+  settings.hooks.BeforeTool ??= [];
+  const matcher = "run_shell_command|grep|search";
+  const already = settings.hooks.BeforeTool.some(
+    (e) => e?.matcher === matcher && Array.isArray(e?.hooks) &&
+      e.hooks.some((h) => typeof h?.command === "string" && h.command.includes("agentmap-nudge")),
+  );
+
+  if (dryRun) return targets;
+  if (!existsSync(GEMINI_NUDGE_SRC)) throw new Error(`packaged hook missing: ${GEMINI_NUDGE_SRC}`);
+  mkdirSync(dirname(nudgeDest), { recursive: true });
+  writeFileSync(nudgeDest, readFileSync(GEMINI_NUDGE_SRC, "utf8"));
+
+  if (!already) {
+    settings.hooks.BeforeTool.push({
+      matcher,
+      hooks: [{
+        name: "agentmap-nudge",
+        type: "command",
+        command: NUDGE_CMD,
+        timeout: 5000,
+        description: "Nudge structural searches toward agentmap",
+      }],
+    });
+    atomicWrite(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  }
+  return targets;
+}
+
+/** @returns {string[]} relative paths touched */
+export function installOpencodePlugin(root, dryRun) {
+  if (root !== process.cwd()) return [];
+  const dest = ".opencode/plugins/agentmap-nudge.js";
+  if (dryRun) return [dest];
+  if (!existsSync(OPENCODE_PLUGIN_SRC)) throw new Error(`packaged plugin missing: ${OPENCODE_PLUGIN_SRC}`);
+  atomicWrite(join(root, dest), readFileSync(OPENCODE_PLUGIN_SRC, "utf8"));
+  return [dest];
+}

package/skills/install.mjs

@@ -1,50 +1,122 @@
 // SPDX-License-Identifier: MIT
-// --install-skill: copy packaged SKILL.md / Cursor rule into project or global
-// agent directories (project or global scope).
+// --install-skill: skill files + always-on docs/hooks per platform (project or global).
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from "node:fs";
-import { homedir } from "node:os";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir, platform as osPlatform } from "node:os";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  atomicWrite,
+  readGuidanceSection,
+  mergeGuidanceBlock,
+  installGeminiHooks,
+  installOpencodePlugin,
+} from "./install-helpers.mjs";
 
 const SKILLS_DIR = dirname(fileURLToPath(import.meta.url));
+const SKILL_MD = join(SKILLS_DIR, "SKILL.md");
+const CURSOR_RULE = join(SKILLS_DIR, "cursor-rule.mdc");
 
-/** @type {Record<string, { label: string; src: string; dest: (root: string) => string; projectOnly?: boolean }>} */
+/** @param {string} root @param {boolean} _globalScope */
+function skillPath(root, _globalScope, ...segments) {
+  return join(root, ...segments);
+}
+
+/** @type {Record<string, {
+ *   label: string;
+ *   src: string;
+ *   dest: (root: string, globalScope: boolean) => string;
+ *   projectOnly?: boolean;
+ *   legacy?: boolean;
+ *   docs?: (root: string, globalScope: boolean) => string;
+ *   hooks?: boolean;
+ *   plugin?: boolean;
+ * }>} */
 const PLATFORMS = {
   claude: {
     label: "Claude Code",
-    src: join(SKILLS_DIR, "SKILL.md"),
-    dest: (root) => join(root, ".claude", "skills", "agentmap", "SKILL.md"),
-  },
-  agents: {
-    label: "Codex / OpenCode (.agents)",
-    src: join(SKILLS_DIR, "SKILL.md"),
-    dest: (root) => join(root, ".agents", "skills", "agentmap", "SKILL.md"),
+    src: SKILL_MD,
+    dest: (root) => skillPath(root, false, ".claude", "skills", "agentmap", "SKILL.md"),
   },
   cursor: {
     label: "Cursor",
-    src: join(SKILLS_DIR, "cursor-rule.mdc"),
-    dest: (root) => join(root, ".cursor", "rules", "agentmap.mdc"),
+    src: CURSOR_RULE,
+    dest: (root) => skillPath(root, false, ".cursor", "rules", "agentmap.mdc"),
     projectOnly: true,
   },
+  codex: {
+    label: "OpenAI Codex",
+    src: SKILL_MD,
+    dest: (root) => skillPath(root, false, ".codex", "skills", "agentmap", "SKILL.md"),
+    docs: (root, globalScope) =>
+      globalScope ? join(root, ".codex", "AGENTS.md") : join(root, "AGENTS.md"),
+  },
+  opencode: {
+    label: "OpenCode",
+    src: SKILL_MD,
+    dest: (root, globalScope) =>
+      globalScope
+        ? join(root, ".config", "opencode", "skills", "agentmap", "SKILL.md")
+        : join(root, ".opencode", "skills", "agentmap", "SKILL.md"),
+    docs: (root, globalScope) =>
+      globalScope ? join(root, ".config", "opencode", "AGENTS.md") : join(root, "AGENTS.md"),
+    plugin: true,
+  },
+  gemini: {
+    label: "Gemini CLI",
+    src: SKILL_MD,
+    dest: (root, globalScope) => {
+      if (!globalScope) return skillPath(root, false, ".gemini", "skills", "agentmap", "SKILL.md");
+      if (osPlatform() === "win32") return skillPath(root, true, ".agents", "skills", "agentmap", "SKILL.md");
+      return skillPath(root, true, ".gemini", "skills", "agentmap", "SKILL.md");
+    },
+    docs: (root, globalScope) => {
+      if (!globalScope) return join(root, "GEMINI.md");
+      if (osPlatform() === "win32") return join(root, ".agents", "GEMINI.md");
+      return join(root, ".gemini", "GEMINI.md");
+    },
+    hooks: true,
+  },
+  antigravity: {
+    label: "Antigravity",
+    src: SKILL_MD,
+    dest: (root, globalScope) =>
+      globalScope
+        ? skillPath(root, true, ".gemini", "config", "skills", "agentmap", "SKILL.md")
+        : skillPath(root, false, ".agents", "skills", "agentmap", "SKILL.md"),
+  },
+  agents: {
+    label: "Amp / legacy .agents",
+    src: SKILL_MD,
+    dest: (root) => skillPath(root, false, ".agents", "skills", "agentmap", "SKILL.md"),
+    legacy: true,
+  },
+  copilot: {
+    label: "GitHub Copilot CLI",
+    src: SKILL_MD,
+    dest: (root) => skillPath(root, false, ".copilot", "skills", "agentmap", "SKILL.md"),
+  },
 };
 
-function atomicWrite(dest, body) {
-  mkdirSync(dirname(dest), { recursive: true });
-  const tmp = `${dest}.tmp`;
-  writeFileSync(tmp, body, "utf8");
-  renameSync(tmp, dest);
-}
+const DEFAULT_PLATFORMS = ["claude", "cursor", "codex", "opencode", "gemini", "antigravity", "copilot"];
 
 function parsePlatforms(raw) {
-  if (!raw || raw === "all") return ["claude", "cursor", "agents"];
-  const names = raw.split(/[,+]/).map((s) => s.trim().toLowerCase()).filter(Boolean);
-  for (const n of names) {
+  const keys = Object.keys(PLATFORMS).join(", ");
+  if (!raw || raw === "all") return [...DEFAULT_PLATFORMS];
+  const tokens = raw.split(/[,+]/).map((s) => s.trim().toLowerCase()).filter(Boolean);
+  if (tokens.includes("all")) {
+    const extra = tokens.filter((t) => t !== "all");
+    for (const n of extra) {
+      if (!PLATFORMS[n]) throw new Error(`unknown platform '${n}' — choose: ${keys}, all`);
+    }
+    return [...new Set([...DEFAULT_PLATFORMS, ...extra])];
+  }
+  for (const n of tokens) {
     if (!PLATFORMS[n]) {
-      throw new Error(`unknown platform '${n}' — choose: ${Object.keys(PLATFORMS).join(", ")}, all`);
+      throw new Error(`unknown platform '${n}' — choose: ${keys}, all`);
     }
   }
-  return names;
+  return tokens;
 }
 
 function gitAddHint(paths) {
@@ -52,18 +124,58 @@ function gitAddHint(paths) {
   if (unique.length) console.log(`\nOptional: git add ${unique.map((p) => `"${p}"`).join(" ")}`);
 }
 
+function installDocsForPlatform(cfg, { root, globalScope, dryRun, guidance, mergedDocs, targets }) {
+  if (!cfg.docs) return;
+  const dest = cfg.docs(root, globalScope);
+  if (mergedDocs.has(dest)) return;
+  mergedDocs.add(dest);
+  const title = dest.endsWith("GEMINI.md") ? "agentmap" : undefined;
+  if (dryRun) {
+    console.log(`  ${cfg.label} docs: ${dest}`);
+    return;
+  }
+  const existing = existsSync(dest) ? readFileSync(dest, "utf8") : "";
+  atomicWrite(dest, mergeGuidanceBlock(existing, guidance, title));
+  console.log(`  ${cfg.label} docs → ${dest}`);
+  targets.push(dest);
+}
+
+function installExtrasForPlatform(name, cfg, { root, globalScope, dryRun, targets }) {
+  if (cfg.hooks && !globalScope) {
+    const hookTargets = installGeminiHooks(root, dryRun);
+    for (const t of hookTargets) {
+      if (dryRun) console.log(`  ${cfg.label} hooks: ${t}`);
+      else {
+        console.log(`  ${cfg.label} hooks → ${t}`);
+        targets.push(t);
+      }
+    }
+  }
+  if (cfg.plugin && !globalScope) {
+    const pluginTargets = installOpencodePlugin(root, dryRun);
+    for (const t of pluginTargets) {
+      if (dryRun) console.log(`  ${cfg.label} plugin: ${t}`);
+      else {
+        console.log(`  ${cfg.label} plugin → ${t}`);
+        targets.push(t);
+      }
+    }
+  }
+}
+
 /**
  * @param {{ platforms?: string; project?: boolean; global?: boolean; dryRun?: boolean }} opts
  */
 export function installSkill({ platforms: platformsArg = "all", project = true, global: globalScope = false, dryRun = false } = {}) {
   if (project && globalScope) throw new Error("use either --project or --global, not both");
-  // read version lazily (inside the function, not at module load) so importing
-  // this module is side-effect-free / off the CLI hot path.
   const VERSION = JSON.parse(readFileSync(join(SKILLS_DIR, "..", "package.json"), "utf8")).version;
   const scope = globalScope ? "global" : "project";
   const root = globalScope ? homedir() : process.cwd();
   const names = parsePlatforms(platformsArg);
   const targets = [];
+  const seenDest = new Set();
+  const mergedDocs = new Set();
+  const guidance = readGuidanceSection();
 
   if (dryRun) console.log(`--dry-run: would install agentmap skill (${scope} scope):`);
 
@@ -74,19 +186,24 @@ export function installSkill({ platforms: platformsArg = "all", project = true,
       continue;
     }
     if (!existsSync(cfg.src)) throw new Error(`packaged skill missing: ${cfg.src}`);
-    const dest = cfg.dest(root);
-    const body = readFileSync(cfg.src, "utf8");
-    const versionFile = join(dirname(dest), ".agentmap_version");
-
-    if (dryRun) {
-      console.log(`  ${cfg.label}: ${dest}`);
-      continue;
+    const dest = cfg.dest(root, globalScope);
+    const skipSkill = seenDest.has(dest);
+    if (skipSkill) {
+      console.log(`  skip ${cfg.label} skill: same path as another platform (${dest})`);
+    } else {
+      seenDest.add(dest);
+      if (dryRun) {
+        console.log(`  ${cfg.label} skill: ${dest}`);
+      } else {
+        atomicWrite(dest, readFileSync(cfg.src, "utf8"));
+        writeFileSync(join(dirname(dest), ".agentmap_version"), VERSION + "\n", "utf8");
+        console.log(`  ${cfg.label} skill → ${dest}`);
+        targets.push(dest);
+      }
     }
 
-    atomicWrite(dest, body);
-    writeFileSync(versionFile, VERSION + "\n", "utf8");
-    console.log(`  ${cfg.label} → ${dest}`);
-    targets.push(dest);
+    installDocsForPlatform(cfg, { root, globalScope, dryRun, guidance, mergedDocs, targets });
+    installExtrasForPlatform(name, cfg, { root, globalScope, dryRun, targets });
   }
 
   if (!dryRun && targets.length) {

package/skills/opencode-agentmap-nudge.js

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+// OpenCode plugin — logs a reminder when bash/grep looks like a structural search.
+// Always-on guidance lives in AGENTS.md (installed by --install-skill).
+// Non-blocking: uses client.app.log when available.
+
+const DEP_RE =
+  /\b(import|require\s*\(|imported\s+by|depends|dependents?|dependency)\b|from\s+["']|(^|\|)\s*export\b/i;
+const INTENT_RE =
+  /\bwhere\s+is\b|\bwho\s+(imports|uses|renders)\b|\breuse\b|\b(existing|shared)\s+(util|component|hook|helper)\b/i;
+const SYMBOL_RE = /\b[A-Z][a-z0-9]+[A-Z][A-Za-z0-9]*\b/;
+
+function shouldNudge(tool, args) {
+  const pattern = String(args?.pattern || args?.query || "");
+  const cmd = String(args?.command || "");
+  if (tool === "grep" && pattern) return DEP_RE.test(pattern) || INTENT_RE.test(pattern);
+  if (tool === "bash" && cmd) {
+    if (!/(^|[;&]\s*)(rg|ripgrep|grep|egrep|fgrep|ag|ack)\b/.test(cmd)) return false;
+    return DEP_RE.test(cmd) || INTENT_RE.test(cmd) || SYMBOL_RE.test(cmd);
+  }
+  return false;
+}
+
+export const AgentmapNudge = async ({ client }) => {
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (!shouldNudge(input.tool, output.args)) return;
+      const message =
+        "Structural search: prefer agentmap --any <query>, --relates <path>, or --find <symbol> before serial grep.";
+      try {
+        await client?.app?.log?.({
+          body: { service: "agentmap", level: "info", message },
+        });
+      } catch {
+        // advisory only
+      }
+    },
+  };
+};