@coworker-jp/aidr 0.0.1

package/README.md

@@ -0,0 +1,55 @@
+# aidr
+
+CLI installer for [ai-scanner](https://github.com/coworker-jp/ai-scanner) hooks across 19+ AI coding agents.
+
+## Quick start
+
+```bash
+npx @coworker-jp/aidr install --agent claude --key ak_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+## Commands
+
+```bash
+aidr install --agent <list|--all> --key <ak_...>
+             [--dry-run] [--force] [--binary-only]
+             [--no-verify] [--skip-binary]
+aidr uninstall [--agent <list>]
+aidr doctor
+aidr list-agents
+```
+
+Options:
+
+- `--agent <list>`: comma-separated names (`claude,cursor`).
+- `--all`: install for every agent detected in `$HOME`.
+- `--key <ak_...>`: access key (format `ak_` + 43 urlsafe chars).
+- `--dry-run`: print planned writes, do not touch disk.
+- `--force`: overwrite existing files.
+- `--binary-only`: fetch only the scanner binary.
+- `--no-verify`: skip the server-side access-key check.
+- `--skip-binary`: skip the scanner binary download.
+
+## Supported agents
+
+| name | status |
+|---|---|
+| claude | full |
+| cursor | full |
+| windsurf | full |
+| kiro | full |
+| gemini | full |
+| codex | full |
+| cline, roo, copilot, qwen, trae, amazonq, jetbrains, opencode, aider, amp, crush, antigravity, continue | stub (Phase 2) |
+
+## Developing
+
+```bash
+node bin/aidr.js list-agents
+node bin/aidr.js install --agent claude --key ak_xxx --dry-run --no-verify --skip-binary
+node --test tests/
+```
+
+## Third-party components
+
+This package downloads and installs [Opengrep](https://github.com/opengrep/opengrep) (LGPL-2.1) alongside the ai-scanner binary. Opengrep is invoked by ai-scanner as a separate process; the process boundary is the license boundary. The upstream binary is shipped unmodified. Set `AI_SCANNER_OPENGREP=/path/to/opengrep` to substitute a different LGPL-2.1 build. See `LICENSES/opengrep-LGPL-2.1.txt` in the downloaded scanner distribution for the full license text and pinned release metadata.

package/bin/aidr.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../src/cli.mjs').then(m => m.run(process.argv)).catch(e => { console.error(e); process.exit(1); });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@coworker-jp/aidr",
+  "version": "0.0.1",
+  "description": "AIDR setup CLI - installs ai-scanner hooks for 19+ AI coding agents",
+  "type": "module",
+  "bin": {
+    "aidr": "./bin/aidr.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "license": "Apache-2.0",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/coworker-jp/ai-scanner"
+  },
+  "scripts": {
+    "test": "node --test tests/"
+  }
+}

package/src/agents/_stub.mjs

@@ -0,0 +1,18 @@
+import path from "node:path";
+
+export function makeStub(name, displayName, configRel) {
+  return {
+    meta: {
+      name,
+      displayName,
+      configDir: (home) => path.join(home, configRel),
+      stub: true,
+    },
+    async install() {
+      console.warn(`[${name}] coming soon — full installer planned for Phase 2`);
+    },
+    async uninstall(installBase, opts = {}) {
+      return { removedFiles: [], settings: { action: "none" }, dirsRemoved: [] };
+    },
+  };
+}

package/src/agents/aider.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("aider", "Aider", ".aider");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/amazonq.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("amazonq", "Amazon Q", ".aws/amazonq");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/amp.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("amp", "Amp", ".amp");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/antigravity.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("antigravity", "Antigravity", ".antigravity");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/claude.mjs

@@ -0,0 +1,92 @@
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { writeFileSafe, writeJsonMerge, unmergeJsonFile, pathExists, rmdirIfEmpty } from "../fs-utils.mjs";
+import * as T from "../templates.mjs";
+import { buildClaudeSettings, mergeClaudeSettings, unmergeClaudeSettings } from "../merge.mjs";
+import { downloadBase } from "../verify.mjs";
+
+const SCRIPT_FILES = [
+  "start_scanner.sh", "stop_scanner.sh",
+  "scan_bash.sh", "scan_bash_input.sh",
+  "scan_edit.sh", "scan_edit_output.sh",
+  "scan_read.sh", "scan_read_input.sh",
+  "scan_webfetch.sh", "scan_websearch.sh",
+  "log_web_urls.sh",
+];
+const BIN_FILES = ["ai-scanner", "opengrep"];
+
+export const meta = {
+  name: "claude",
+  displayName: "Claude Code",
+  agentDir: ".claude",
+  configDir: (home) => path.join(home, ".claude"),
+};
+
+export async function install(installBase, accessKey, opts = {}) {
+  const { dryRun = false, env = "prod", scope = "project" } = opts;
+  const base = meta.configDir(installBase);
+  const aidrDir = path.join(base, "coworker-ai");
+  const dlBase = downloadBase(env);
+  const scriptEntries = [
+    [path.join(aidrDir, "start_scanner.sh"), T.getStartScannerSh(dlBase, "claude-code"), 0o755],
+    [path.join(aidrDir, "stop_scanner.sh"), T.STOP_SCANNER_SH, 0o755],
+    [path.join(aidrDir, "scan_bash.sh"), T.SCAN_BASH_SH, 0o755],
+    [path.join(aidrDir, "scan_bash_input.sh"), T.SCAN_BASH_INPUT_SH, 0o755],
+    [path.join(aidrDir, "scan_edit.sh"), T.SCAN_EDIT_SH, 0o755],
+    [path.join(aidrDir, "scan_edit_output.sh"), T.SCAN_EDIT_OUTPUT_SH, 0o755],
+    [path.join(aidrDir, "scan_read.sh"), T.SCAN_READ_SH, 0o755],
+    [path.join(aidrDir, "scan_read_input.sh"), T.SCAN_READ_INPUT_SH, 0o755],
+    [path.join(aidrDir, "scan_webfetch.sh"), T.SCAN_WEBFETCH_SH, 0o755],
+    [path.join(aidrDir, "scan_websearch.sh"), T.SCAN_WEBSEARCH_SH, 0o755],
+    [path.join(aidrDir, "log_web_urls.sh"), T.LOG_WEB_URLS_SH, 0o755],
+  ];
+  const settingsPath = path.join(base, "settings.json");
+  const [settingsRes, ...scriptResults] = await Promise.all([
+    writeJsonMerge(settingsPath, buildClaudeSettings(accessKey, scope), mergeClaudeSettings, { dryRun }),
+    ...scriptEntries.map(([p, c, mode]) => writeFileSafe(p, c, { dryRun, force: true, backup: false, mode })),
+  ]);
+  const scriptBackups = scriptResults.map((r) => r && r.backupPath).filter(Boolean);
+  return {
+    installed: [settingsPath, ...scriptEntries.map(([p]) => p)],
+    backupPath: settingsRes.backupPath,
+    backupPaths: [
+      ...(settingsRes.backupPath ? [settingsRes.backupPath] : []),
+      ...scriptBackups,
+    ],
+  };
+}
+
+// Plan + execute uninstall. With dryRun: plan is computed and returned but no
+// writes happen. Returns { removedFiles, settings, dirsRemoved } so the caller
+// (cli.mjs) can print the plan and confirm with the user.
+export async function uninstall(installBase, opts = {}) {
+  const { dryRun = false } = opts;
+  const base = meta.configDir(installBase);
+  const aidrDir = path.join(base, "coworker-ai");
+  const binDir = path.join(base, "bin");
+  const settingsPath = path.join(base, "settings.json");
+
+  const candidateFiles = [
+    ...SCRIPT_FILES.map(n => path.join(aidrDir, n)),
+    ...BIN_FILES.map(n => path.join(binDir, n)),
+  ];
+  const removedFiles = [];
+  for (const f of candidateFiles) {
+    if (await pathExists(f)) removedFiles.push(f);
+  }
+
+  const settings = await unmergeJsonFile(settingsPath, unmergeClaudeSettings, { dryRun });
+
+  if (dryRun) {
+    return { removedFiles, settings, dirsRemoved: [] };
+  }
+
+  await Promise.all(removedFiles.map(f => fsp.rm(f, { force: true })));
+  const dirsRemoved = [];
+  // rmdirIfEmpty only removes the dir if empty, so user-authored files in
+  // .claude/coworker-ai/ keep the dir alive.
+  for (const d of [aidrDir, binDir]) {
+    if (await rmdirIfEmpty(d)) dirsRemoved.push(d);
+  }
+  return { removedFiles, settings, dirsRemoved };
+}

package/src/agents/cline.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("cline", "Cline", ".cline");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/codex.mjs

@@ -0,0 +1,225 @@
+import path from "node:path";
+import fsp from "node:fs/promises";
+import {
+  writeFileSafe,
+  writeJsonMerge,
+  unmergeJsonFile,
+  pathExists,
+  rmdirIfEmpty,
+  backupPathFor,
+} from "../fs-utils.mjs";
+import * as T from "../templates.mjs";
+import {
+  buildCodexHooksJson,
+  mergeCodexHooksJson,
+  unmergeCodexHooksJson,
+} from "../merge.mjs";
+import { mergeCodexHookFeature, unmergeCodexHookFeature } from "../toml-merge.mjs";
+import { downloadBase } from "../verify.mjs";
+
+// Owned scripts under .codex/coworker-ai/. hooks.json and config.toml are NOT
+// listed here because they're merged (not overwritten) — uninstall handles
+// them separately via the unmerge helpers below.
+const SCRIPT_FILES = [
+  "env.sh",
+  "start_scanner.sh",
+  "session_init.sh",
+  "pre_shell.sh",
+  "post_shell.sh",
+];
+const BIN_FILES = ["ai-scanner", "opengrep"];
+const ROOT_FILES = ["AGENTS.md"];
+
+export const meta = {
+  name: "codex",
+  displayName: "Codex CLI",
+  agentDir: ".codex",
+  configDir: (home) => path.join(home, ".codex"),
+};
+
+const CODEX_AGENTS_MD = `# AIDR Scanner
+
+AIDR security scanner is active for this Codex session. Set the access key
+via the \`AI_SCANNER_ACCESS_KEY\` environment variable. Hooks are registered
+in \`.codex/hooks.json\` and require \`[features] codex_hooks = true\` in
+\`.codex/config.toml\` (this setup writes both for you).
+
+Codex currently emits Bash tool events only. Read / Edit / WebFetch / WebSearch
+are not hookable — for those, use Claude Code.
+`;
+
+export async function install(installBase, accessKey, opts = {}) {
+  const { dryRun = false, env = "prod", scope = "project", home = installBase } = opts;
+  const base = meta.configDir(installBase);
+  const aidrDir = path.join(base, "coworker-ai");
+  const dlBase = downloadBase(env);
+
+  // 1) Merge hooks.json — preserves user's own hooks if any.
+  const hooksRes = await writeJsonMerge(
+    path.join(base, "hooks.json"),
+    buildCodexHooksJson(scope, home),
+    mergeCodexHooksJson,
+    { dryRun, mode: 0o644 },
+  );
+
+  // 2) Merge config.toml to enable the feature flag. Backs up pre-merge TOML
+  //    so a rollback is possible if our merge logic corrupts the file.
+  const tomlRes = await mergeCodexConfigToml(path.join(base, "config.toml"), { dryRun });
+
+  // 3) Write owned scripts + AGENTS.md. AGENTS.md is plain prose owned by us
+  //    so we keep a backup; the regenerated shell wrappers skip backup.
+  const markdownEntry = [path.join(base, "AGENTS.md"), CODEX_AGENTS_MD, 0o644];
+  const scriptEntries = [
+    [path.join(aidrDir, "env.sh"), T.agentEnvSh(accessKey, meta.agentDir), 0o755],
+    [path.join(aidrDir, "start_scanner.sh"), T.getStartScannerSh(dlBase, "codex"), 0o755],
+    [path.join(aidrDir, "session_init.sh"), T.CODEX_SESSION_INIT_SH, 0o755],
+    [path.join(aidrDir, "pre_shell.sh"), T.CODEX_PRE_SHELL_SH, 0o755],
+    [path.join(aidrDir, "post_shell.sh"), T.CODEX_POST_SHELL_SH, 0o755],
+  ];
+  const entries = [markdownEntry, ...scriptEntries];
+  const [markdownRes, ...shScriptResults] = await Promise.all([
+    writeFileSafe(markdownEntry[0], markdownEntry[1], { dryRun, force: true, mode: markdownEntry[2] }),
+    ...scriptEntries.map(([p, c, mode]) => writeFileSafe(p, c, { dryRun, force: true, backup: false, mode })),
+  ]);
+  const scriptResults = [markdownRes, ...shScriptResults];
+
+  const backupPaths = [
+    ...(hooksRes && hooksRes.backupPath ? [hooksRes.backupPath] : []),
+    ...(tomlRes && tomlRes.backupPath ? [tomlRes.backupPath] : []),
+    ...scriptResults.map((r) => r && r.backupPath).filter(Boolean),
+  ];
+
+  return {
+    installed: [
+      path.join(base, "hooks.json"),
+      path.join(base, "config.toml"),
+      ...entries.map(([p]) => p),
+    ],
+    backupPaths,
+  };
+}
+
+export async function uninstall(installBase, opts = {}) {
+  const { dryRun = false } = opts;
+  const base = meta.configDir(installBase);
+  const aidrDir = path.join(base, "coworker-ai");
+  const binDir = path.join(base, "bin");
+
+  const candidateFiles = [
+    ...ROOT_FILES.map((n) => path.join(base, n)),
+    ...SCRIPT_FILES.map((n) => path.join(aidrDir, n)),
+    ...BIN_FILES.map((n) => path.join(binDir, n)),
+  ];
+  const removedFiles = [];
+  for (const f of candidateFiles) {
+    // eslint-disable-next-line no-await-in-loop
+    if (await pathExists(f)) removedFiles.push(f);
+  }
+
+  // Unmerge hooks.json + config.toml instead of unconditional rm.
+  const hooksAction = await unmergeJsonFile(
+    path.join(base, "hooks.json"),
+    unmergeCodexHooksJson,
+    { dryRun },
+  );
+  const tomlAction = await unmergeCodexConfigToml(path.join(base, "config.toml"), { dryRun });
+
+  if (dryRun) {
+    return {
+      removedFiles,
+      settings: { action: "unmerge", hooksJson: hooksAction, configToml: tomlAction },
+      dirsRemoved: [],
+    };
+  }
+
+  await Promise.all(removedFiles.map((f) => fsp.rm(f, { force: true })));
+  const dirsRemoved = [];
+  for (const d of [aidrDir, binDir]) {
+    // eslint-disable-next-line no-await-in-loop
+    if (await rmdirIfEmpty(d)) dirsRemoved.push(d);
+  }
+
+  return {
+    removedFiles,
+    settings: { action: "unmerge", hooksJson: hooksAction, configToml: tomlAction },
+    dirsRemoved,
+  };
+}
+
+// ── TOML helpers (Codex-specific) ─────────────────────────────────────
+async function mergeCodexConfigToml(target, { dryRun, stderr = process.stderr }) {
+  // Refuse to follow a user-intentional symlink (same policy as writeJsonMerge).
+  let stat = null;
+  try { stat = await fsp.lstat(target); }
+  catch (e) { if (e.code !== "ENOENT") throw e; }
+  if (stat && stat.isSymbolicLink()) {
+    throw new Error(
+      `${target} is a symlink. Refusing to overwrite. ` +
+      `Remove the symlink and re-run, or edit the target file manually.`
+    );
+  }
+
+  let existing = "";
+  if (stat) {
+    existing = await fsp.readFile(target, "utf8");
+  }
+
+  const merged = mergeCodexHookFeature(existing);
+  if (merged === existing) {
+    return { action: "noop", path: target, backupPath: null };
+  }
+  if (dryRun) {
+    if (stat) {
+      stderr.write(
+        `WARNING: ${target} already exists. (dry-run: would back up)\n` +
+        `Merging [features] codex_hooks; your other settings are preserved.\n`
+      );
+    }
+    process.stdout.write(
+      `\n--- [dry-run] ${target} (merged TOML, ${merged.length} bytes) ---\n${merged}\n--- end ---\n`,
+    );
+    return { action: "would-merge", path: target, backupPath: null };
+  }
+
+  // Back up the pre-merge TOML so a rollback after a bad merge is always possible.
+  let backupPath = null;
+  if (stat) {
+    backupPath = backupPathFor(target);
+    await fsp.copyFile(target, backupPath);
+    stderr.write(
+      `WARNING: ${target} already exists. Backed up to ${backupPath}.\n` +
+      `Merging [features] codex_hooks; your other settings are preserved.\n`
+    );
+  }
+
+  await fsp.mkdir(path.dirname(target), { recursive: true });
+  const tmp = `${target}.aidr-tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  await fsp.writeFile(tmp, merged, { mode: 0o644 });
+  await fsp.chmod(tmp, 0o644);
+  await fsp.rename(tmp, target);
+  return { action: "merge", path: target, backupPath };
+}
+
+async function unmergeCodexConfigToml(target, { dryRun }) {
+  let existing = "";
+  try { existing = await fsp.readFile(target, "utf8"); }
+  catch (e) {
+    if (e.code === "ENOENT") return { action: "none", path: target };
+    throw e;
+  }
+  const { text, empty } = unmergeCodexHookFeature(existing);
+  if (text === existing) return { action: "noop", path: target };
+
+  if (dryRun) {
+    return { action: empty ? "delete" : "modify", path: target, preview: empty ? null : text };
+  }
+  if (empty) {
+    await fsp.rm(target, { force: true });
+    return { action: "delete", path: target };
+  }
+  const tmp = `${target}.aidr-tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  await fsp.writeFile(tmp, text, { mode: 0o644 });
+  await fsp.chmod(tmp, 0o644);
+  await fsp.rename(tmp, target);
+  return { action: "modify", path: target };
+}

package/src/agents/continue.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("continue", "Continue", ".continue");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/copilot.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("copilot", "GitHub Copilot", ".github/copilot");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/crush.mjs

@@ -0,0 +1,5 @@
+import { makeStub } from "./_stub.mjs";
+const s = makeStub("crush", "Crush", ".crush");
+export const meta = s.meta;
+export const install = s.install;
+export const uninstall = s.uninstall;

package/src/agents/cursor.mjs

@@ -0,0 +1,109 @@
+import path from "node:path";
+import fsp from "node:fs/promises";
+import {
+  writeFileSafe,
+  writeJsonMerge,
+  unmergeJsonFile,
+  pathExists,
+  rmdirIfEmpty,
+} from "../fs-utils.mjs";
+import * as T from "../templates.mjs";
+import {
+  buildCursorHooksJson,
+  mergeCursorHooksJson,
+  unmergeCursorHooksJson,
+} from "../merge.mjs";
+import { downloadBase } from "../verify.mjs";
+
+// hooks.json is merged (not listed here); only scripts/bin files are
+// unconditionally owned and can be rm'd on uninstall.
+const SCRIPT_FILES = [
+  "env.sh",
+  "start_scanner.sh",
+  "session-init.sh",
+  "pre_shell.sh",
+  "pre_read.sh",
+  "pre_edit.sh",
+  "post_shell.sh",
+  "post_read.sh",
+  "post_write.sh",
+];
+const BIN_FILES = ["ai-scanner", "opengrep"];
+
+export const meta = {
+  name: "cursor",
+  displayName: "Cursor",
+  agentDir: ".cursor",
+  configDir: (home) => path.join(home, ".cursor"),
+};
+
+export async function install(installBase, accessKey, opts = {}) {
+  const { dryRun = false, env = "prod", scope = "project", home = installBase } = opts;
+  const base = meta.configDir(installBase);
+  const aidrDir = path.join(base, "coworker-ai");
+  const dlBase = downloadBase(env);
+
+  const hooksRes = await writeJsonMerge(
+    path.join(base, "hooks.json"),
+    buildCursorHooksJson(scope, home),
+    mergeCursorHooksJson,
+    { dryRun, mode: 0o644 },
+  );
+
+  const entries = [
+    [path.join(aidrDir, "env.sh"), T.agentEnvSh(accessKey, meta.agentDir), 0o755],
+    [path.join(aidrDir, "start_scanner.sh"), T.getStartScannerSh(dlBase, "cursor"), 0o755],
+    [path.join(aidrDir, "session-init.sh"), T.getCursorSessionInitSh(accessKey), 0o755],
+    [path.join(aidrDir, "pre_shell.sh"), T.CURSOR_PRE_SHELL_SH, 0o755],
+    [path.join(aidrDir, "pre_read.sh"), T.CURSOR_PRE_READ_SH, 0o755],
+    [path.join(aidrDir, "pre_edit.sh"), T.CURSOR_PRE_EDIT_SH, 0o755],
+    [path.join(aidrDir, "post_shell.sh"), T.CURSOR_POST_SHELL_SH, 0o755],
+    [path.join(aidrDir, "post_read.sh"), T.CURSOR_POST_READ_SH, 0o755],
+    [path.join(aidrDir, "post_write.sh"), T.CURSOR_POST_WRITE_SH, 0o755],
+  ];
+  const scriptResults = await Promise.all(
+    entries.map(([p, c, mode]) => writeFileSafe(p, c, { dryRun, force: true, backup: false, mode })),
+  );
+  const backupPaths = [
+    ...(hooksRes && hooksRes.backupPath ? [hooksRes.backupPath] : []),
+    ...scriptResults.map((r) => r && r.backupPath).filter(Boolean),
+  ];
+  return {
+    installed: [path.join(base, "hooks.json"), ...entries.map(([p]) => p)],
+    backupPaths,
+  };
+}
+
+export async function uninstall(installBase, opts = {}) {
+  const { dryRun = false } = opts;
+  const base = meta.configDir(installBase);
+  const aidrDir = path.join(base, "coworker-ai");
+  const binDir = path.join(base, "bin");
+
+  const candidateFiles = [
+    ...SCRIPT_FILES.map((n) => path.join(aidrDir, n)),
+    ...BIN_FILES.map((n) => path.join(binDir, n)),
+  ];
+  const checks = await Promise.all(
+    candidateFiles.map(async (p) => ((await pathExists(p)) ? p : null)),
+  );
+  const removedFiles = checks.filter((p) => p !== null);
+
+  const hooksAction = await unmergeJsonFile(
+    path.join(base, "hooks.json"),
+    unmergeCursorHooksJson,
+    { dryRun },
+  );
+
+  if (dryRun) {
+    return { removedFiles, settings: { action: "unmerge", hooksJson: hooksAction }, dirsRemoved: [] };
+  }
+
+  await Promise.all(removedFiles.map((f) => fsp.rm(f, { force: true })));
+  const dirChecks = await Promise.all(
+    [aidrDir, binDir].map(async (d) => ((await rmdirIfEmpty(d)) ? d : null)),
+  );
+  const dirsRemoved = dirChecks.filter((d) => d !== null);
+
+  return { removedFiles, settings: { action: "unmerge", hooksJson: hooksAction }, dirsRemoved };
+}

package/src/agents/gemini.mjs

@@ -0,0 +1,66 @@
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { writeFileSafe, writeJsonMerge, unmergeJsonFile, pathExists, rmdirIfEmpty } from "../fs-utils.mjs";
+import * as T from "../templates.mjs";
+import { buildGeminiSettings, mergeGeminiSettings, unmergeGeminiSettings } from "../merge.mjs";
+
+const HOOK_FILES = ["aidr-pre.sh"];
+const BIN_FILES = ["ai-scanner", "opengrep"];
+
+export const meta = {
+  name: "gemini",
+  displayName: "Gemini CLI",
+  agentDir: ".gemini",
+  configDir: (home) => path.join(home, ".gemini"),
+};
+
+export async function install(home, accessKey, opts = {}) {
+  const { dryRun = false } = opts;
+  const base = meta.configDir(home);
+  const hooks = path.join(base, "hooks");
+  const binary = path.join(home, meta.agentDir, "bin", "ai-scanner");
+  const settingsPath = path.join(base, "settings.json");
+  const preHookPath = path.join(hooks, "aidr-pre.sh");
+  const [settingsRes, hookRes] = await Promise.all([
+    writeJsonMerge(settingsPath, buildGeminiSettings(accessKey, binary), mergeGeminiSettings, { dryRun }),
+    writeFileSafe(preHookPath, T.getGeminiPreHookSh(binary), { dryRun, force: true, mode: 0o755 }),
+  ]);
+  return {
+    installed: [settingsPath, preHookPath],
+    backupPath: settingsRes.backupPath,
+    backupPaths: [
+      ...(settingsRes.backupPath ? [settingsRes.backupPath] : []),
+      ...(hookRes.backupPath ? [hookRes.backupPath] : []),
+    ],
+  };
+}
+
+export async function uninstall(installBase, opts = {}) {
+  const { dryRun = false } = opts;
+  const base = meta.configDir(installBase);
+  const hooksDir = path.join(base, "hooks");
+  const binDir = path.join(base, "bin");
+  const settingsPath = path.join(base, "settings.json");
+
+  const candidateFiles = [
+    ...HOOK_FILES.map(n => path.join(hooksDir, n)),
+    ...BIN_FILES.map(n => path.join(binDir, n)),
+  ];
+  const removedFiles = [];
+  for (const f of candidateFiles) {
+    if (await pathExists(f)) removedFiles.push(f);
+  }
+
+  const settings = await unmergeJsonFile(settingsPath, unmergeGeminiSettings, { dryRun });
+
+  if (dryRun) {
+    return { removedFiles, settings, dirsRemoved: [] };
+  }
+
+  await Promise.all(removedFiles.map(f => fsp.rm(f, { force: true })));
+  const dirsRemoved = [];
+  for (const d of [hooksDir, binDir]) {
+    if (await rmdirIfEmpty(d)) dirsRemoved.push(d);
+  }
+  return { removedFiles, settings, dirsRemoved };
+}