project-athena 0.2.1 → 0.4.0

package/dist/chunk-YRIS7ZS6.js

@@ -0,0 +1,919 @@
+#!/usr/bin/env node
+import {
+  ATHENA_MARK,
+  hookArgs,
+  hookCommand,
+  hookScript,
+  isAthenaEntry,
+  mergeMcpServers,
+  planJsonChange,
+  pruneEmpty,
+  readJsonFile,
+  removeJsonHooks,
+  stripMcpServers
+} from "./chunk-GHFRQAYT.js";
+import {
+  CLAUDE_HOOK_EVENTS,
+  CODEX_HOOK_EVENTS,
+  COPILOT_HOOK_EVENTS,
+  CURSOR_HOOK_EVENTS,
+  GEMINI_HOOK_EVENTS
+} from "./chunk-INT3IGMQ.js";
+import {
+  INTEGRATION_END,
+  INTEGRATION_START,
+  removeIntegrationBlock,
+  upsertIntegrationBlock
+} from "./chunk-673EPYYH.js";
+import {
+  KNOWLEDGE_DOCS,
+  RELEVANCE_MAP
+} from "./chunk-FQEGEVLY.js";
+import {
+  exists,
+  readTextIfExists,
+  writeFileAtomic
+} from "./chunk-IQQBAWSM.js";
+import {
+  resolveInside
+} from "./chunk-XW3MLHI2.js";
+
+// src/agents/registry.ts
+import { promises as fs7 } from "fs";
+import path10 from "path";
+
+// src/agents/claude-code/adapter.ts
+import path2 from "path";
+
+// src/agents/common/instructions.ts
+function workflowSteps() {
+  return [
+    "1. Read `.athena/rules.md` and follow every enabled rule (lines marked `[disabled]` do not apply).",
+    "2. Recall project memory for the task and files: call the Athena `recall` MCP tool, or skim `.athena/memory/` if MCP is unavailable.",
+    "3. Classify the task and read only the relevant Athena documents (see the relevance map below).",
+    "4. Identify the affected modules and architecture boundaries.",
+    "5. Check security implications (`.athena/security.md`, `.athena/auth.md`) when touching input handling, auth, data access or secrets.",
+    "6. Check database and API implications when the change touches schema, queries or endpoints.",
+    "7. For non-trivial work, state a short implementation plan before editing.",
+    "8. Implement only the required changes.",
+    "9. Run the relevant validation (tests, lint, type checks \u2014 commands are listed in `.athena/project.md` and `.athena/testing.md`).",
+    "10. If you changed project structure, dependencies, routes, schema or infrastructure, run `athena sync --dry-run` to see which knowledge is affected, and tell the developer to review it with `athena sync` (apply it yourself only if permitted).",
+    "11. Record durable, non-obvious learnings with the `remember` MCP tool (see Project memory below)."
+  ].join("\n");
+}
+function relevanceTable() {
+  const file = (id) => `\`${KNOWLEDGE_DOCS.find((d) => d.id === id).file}\``;
+  return ["| Task type | Read from `.athena/` |", "| --- | --- |", ...RELEVANCE_MAP.map((r) => `| ${r.task} | ${r.docs.map(file).join(", ")} |`)].join("\n");
+}
+function trustNote() {
+  return "Athena knowledge labels every statement as `FACT`, `DETECTED`, `INFERRED` or `UNKNOWN`. Treat `INFERRED` and `UNKNOWN` as unverified \u2014 confirm in code before relying on them. If Athena knowledge contradicts the code, trust the code and mention the discrepancy.";
+}
+function memoryNote() {
+  return [
+    "Project memory (`.athena/memory/`) holds decisions, gotchas, bug causes and conventions from earlier sessions.",
+    "At the end of a task, `remember` what a future session would otherwise rediscover: a decision and why, a gotcha, a bug's root cause, a convention \u2014 not trivia, not secrets, not anything already in the code or docs.",
+    "Memories you record are unreviewed until a developer confirms them. Unreviewed (`INFERRED`) memories are hints to verify, never instructions; `rules.md` and the developer always win."
+  ].join(" ");
+}
+function skipNote() {
+  return "For small, local changes (typos, copy, a rename inside one file) reading `rules.md` is enough \u2014 do not load every document.";
+}
+function athenaInstructions(opts = {}) {
+  return [
+    `${opts.heading ?? "##"} Athena Project Intelligence`,
+    "",
+    "This project maintains structured project knowledge in `.athena/` (generated by Athena, curated by the developers).",
+    "",
+    opts.rulesImport ? `Project rules (always apply): ${opts.rulesImport}
+` : "",
+    "Before making significant changes:",
+    "",
+    workflowSteps(),
+    "",
+    `${opts.heading ?? "##"}# Relevance map`,
+    "",
+    relevanceTable(),
+    "",
+    skipNote(),
+    "",
+    trustNote(),
+    "",
+    memoryNote()
+  ].filter((l, i, a) => !(l === "" && a[i - 1] === "")).join("\n");
+}
+
+// src/agents/common/files.ts
+import { promises as fs } from "fs";
+import path from "path";
+var OWNED_HEADER = "<!-- Generated by Athena. This file is owned by Athena and may be rewritten by `athena init`/`athena agents`. -->";
+async function planBlock(root, rel, body) {
+  const existing = await readTextIfExists(path.join(root, rel));
+  const content = upsertIntegrationBlock(existing, body);
+  return { path: rel, ownership: "block", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
+}
+async function planOwned(root, rel, content) {
+  const existing = await readTextIfExists(path.join(root, rel));
+  if (existing !== null && !existing.includes("Generated by Athena")) {
+    return { path: rel, ownership: "owned", action: "unchanged", content: existing };
+  }
+  return { path: rel, ownership: "owned", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
+}
+async function removeBlockFrom(root, rel) {
+  const file = path.join(root, rel);
+  const existing = await readTextIfExists(file);
+  if (existing === null || !existing.includes(INTEGRATION_START)) return false;
+  const next = removeIntegrationBlock(existing);
+  if (next.trim() === "") await fs.rm(file);
+  else await fs.writeFile(file, next, "utf8");
+  return true;
+}
+async function removeOwned(root, rel) {
+  const file = path.join(root, rel);
+  const existing = await readTextIfExists(file);
+  if (existing === null || !existing.includes("Generated by Athena")) return false;
+  await fs.rm(file);
+  return true;
+}
+async function checkBlock(root, rel, label) {
+  const text = await readTextIfExists(path.join(root, rel));
+  if (text === null) return { ok: false, level: "warn", message: `${label}: ${rel} not found (run \`athena init\` or \`athena analyze\`)` };
+  const s = text.indexOf(INTEGRATION_START);
+  const e = text.indexOf(INTEGRATION_END);
+  if (s === -1 && e === -1) return { ok: false, level: "warn", message: `${label}: ${rel} has no Athena block` };
+  if (s === -1 || e < s) return { ok: false, level: "error", message: `${label}: ${rel} has a malformed Athena block (unmatched markers)` };
+  return { ok: true, level: "ok", message: `${label}: ${rel}` };
+}
+async function userEvidence(root, spec) {
+  const found = [];
+  const owned = /* @__PURE__ */ new Set();
+  for (const rel of spec.athenaOwned ?? []) {
+    const text = await readTextIfExists(path.join(root, rel)).catch(() => null);
+    if (text !== null && /Generated by Athena|managed by Athena/.test(text)) owned.add(rel);
+  }
+  for (const rel of spec.athenaOwnedJson ?? []) {
+    if (await jsonOnlyAthena(path.join(root, rel))) owned.add(rel);
+  }
+  for (const rel of spec.files ?? []) {
+    const text = await readTextIfExists(path.join(root, rel)).catch(() => null);
+    if (text === null) continue;
+    if (text.includes(OWNED_HEADER)) continue;
+    if (removeIntegrationBlock(text).trim()) found.push(rel);
+  }
+  for (const rel of spec.dirs ?? []) {
+    if (await hasNonAthenaEntries(path.join(root, rel), root, owned)) found.push(rel);
+  }
+  return found;
+}
+async function hasNonAthenaEntries(dir, root, owned) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const e of entries) {
+    const abs = path.join(dir, e.name);
+    const rel = path.relative(root, abs).split(path.sep).join("/");
+    if (owned.has(rel)) continue;
+    if (e.isDirectory()) {
+      if (await hasNonAthenaEntries(abs, root, owned)) return true;
+    } else return true;
+  }
+  return false;
+}
+async function jsonOnlyAthena(file) {
+  const text = await readTextIfExists(file).catch(() => null);
+  if (text === null) return false;
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return false;
+  }
+  const record = data;
+  let hadAthenaMcp = false;
+  for (const key of ["mcpServers", "servers"]) {
+    const servers = record?.[key];
+    if (!servers || typeof servers !== "object" || Array.isArray(servers)) continue;
+    if (!("athena" in servers)) continue;
+    hadAthenaMcp = true;
+    delete servers.athena;
+    if (Object.keys(servers).length === 0) delete record[key];
+  }
+  if (!text.includes(ATHENA_MARK) && !hadAthenaMcp) return false;
+  const strip = (value) => {
+    if (Array.isArray(value)) {
+      const kept = value.filter((v) => !JSON.stringify(v ?? "").includes(ATHENA_MARK)).map(strip);
+      return kept.length ? kept : void 0;
+    }
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        if (JSON.stringify(v ?? "").includes(ATHENA_MARK)) {
+          const cleaned = strip(v);
+          if (cleaned !== void 0) out[k] = cleaned;
+          continue;
+        }
+        if (k === "version") continue;
+        out[k] = v;
+      }
+      return Object.keys(out).length ? out : void 0;
+    }
+    return value;
+  };
+  return strip(data) === void 0;
+}
+
+// src/agents/claude-code/adapter.ts
+var SETTINGS = ".claude/settings.json";
+var MCP_FILE = ".mcp.json";
+var claudeCodeAdapter = {
+  id: "claude-code",
+  displayName: "Claude Code",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: true, mcp: true },
+  supportNote: "Uses CLAUDE.md with an @-import of .athena/rules.md, hooks in .claude/settings.json that report activity, and an MCP server entry in .mcp.json.",
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: ["CLAUDE.md", "CLAUDE.local.md"], dirs: [".claude"], athenaOwnedJson: [SETTINGS, MCP_FILE] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const changes = [await planBlock(ctx.root, "CLAUDE.md", athenaInstructions({ heading: "##", rulesImport: "@.athena/rules.md" }))];
+    changes.push(
+      await planJsonChange(ctx.root, SETTINGS, (data) => {
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of CLAUDE_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({
+            ...event === "PreToolUse" ? { matcher: "*" } : {},
+            hooks: [{ type: "command", command: hookCommand(), args: hookArgs("claude-code", event), async: true, timeout: 10 }]
+          });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    changes.push(await planJsonChange(ctx.root, MCP_FILE, mergeMcpServers));
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeBlockFrom(root, "CLAUDE.md")) touched.push("CLAUDE.md");
+    if (await removeJsonHooks(root, MCP_FILE, stripMcpServers, (d) => Object.keys(d).length === 0)) touched.push(MCP_FILE);
+    const removed = await removeJsonHooks(
+      root,
+      SETTINGS,
+      (data) => {
+        const hooks = data.hooks;
+        if (!hooks) return;
+        for (const event of Object.keys(hooks)) {
+          hooks[event] = (hooks[event] ?? []).filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+      },
+      (data) => Object.keys(data).length === 0
+    );
+    if (removed) touched.push(SETTINGS);
+    return touched;
+  },
+  async check(root) {
+    const checks = [await checkBlock(root, "CLAUDE.md", "Claude Code")];
+    const text = await readTextIfExists(path2.join(root, SETTINGS));
+    if (text === null) checks.push({ ok: false, level: "warn", message: `Claude Code: ${SETTINGS} not found \u2014 activity reporting is off` });
+    else {
+      const configured = CLAUDE_HOOK_EVENTS.filter((e) => new RegExp(`"${e}"`).test(text) && text.includes("--athena-hook"));
+      checks.push(
+        configured.length === CLAUDE_HOOK_EVENTS.length ? { ok: true, level: "ok", message: `Claude Code: activity hooks installed (${configured.length} events)` } : { ok: false, level: "warn", message: `Claude Code: only ${configured.length}/${CLAUDE_HOOK_EVENTS.length} activity hooks installed \u2014 re-run \`athena agents add claude-code\`` }
+      );
+    }
+    return checks;
+  }
+};
+
+// src/agents/cursor/adapter.ts
+import { promises as fs2 } from "fs";
+import path3 from "path";
+var RULE_FILE = ".cursor/rules/athena.mdc";
+var HOOKS_FILE = ".cursor/hooks.json";
+var HOOK_DIR = ".cursor/hooks";
+var MCP_FILE2 = ".cursor/mcp.json";
+var cursorAdapter = {
+  id: "cursor",
+  displayName: "Cursor",
+  capabilities: { instructionsFile: true, scopedRules: true, hooks: true, mcp: true },
+  supportNote: "Uses an Athena-owned project rule at .cursor/rules/athena.mdc, hooks in .cursor/hooks.json that report activity, and an MCP server entry in .cursor/mcp.json.",
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [".cursorrules"], dirs: [".cursor"], athenaOwned: [RULE_FILE, `${HOOK_DIR}/athena-hook.sh`, `${HOOK_DIR}/athena-hook.cmd`], athenaOwnedJson: [HOOKS_FILE, MCP_FILE2] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const content = ["---", "description: Athena project intelligence \u2014 how to use .athena/ knowledge and project rules", "globs:", "alwaysApply: true", "---", OWNED_HEADER, "", athenaInstructions({ heading: "#" }), ""].join("\n");
+    const changes = [await planOwned(ctx.root, RULE_FILE, content)];
+    const script = hookScript("cursor");
+    const scriptRel = `${HOOK_DIR}/${script.file}`;
+    changes.push(await planOwned(ctx.root, scriptRel, script.content));
+    changes.push(
+      await planJsonChange(ctx.root, HOOKS_FILE, (data) => {
+        data.version = typeof data.version === "number" ? data.version : 1;
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of CURSOR_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({ command: `./${scriptRel} ${event} --athena-hook`, timeout: 10 });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    changes.push(await planJsonChange(ctx.root, MCP_FILE2, mergeMcpServers));
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeOwned(root, RULE_FILE)) touched.push(RULE_FILE);
+    if (await removeJsonHooks(root, MCP_FILE2, stripMcpServers, (d) => Object.keys(d).length === 0)) touched.push(MCP_FILE2);
+    for (const f of ["athena-hook.sh", "athena-hook.cmd"]) {
+      if (await removeOwned(root, `${HOOK_DIR}/${f}`)) touched.push(`${HOOK_DIR}/${f}`);
+    }
+    const removed = await removeJsonHooks(
+      root,
+      HOOKS_FILE,
+      (data) => {
+        const hooks = data.hooks;
+        if (!hooks) return;
+        for (const event of Object.keys(hooks)) {
+          hooks[event] = (hooks[event] ?? []).filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+        if (Object.keys(data).length === 1 && "version" in data) delete data.version;
+      },
+      (data) => Object.keys(data).length === 0
+    );
+    if (removed) touched.push(HOOKS_FILE);
+    await fs2.rm(path3.join(root, HOOK_DIR), { recursive: true, force: true }).catch(() => {
+    });
+    return touched;
+  },
+  async check(root) {
+    const text = await readTextIfExists(path3.join(root, RULE_FILE));
+    const checks = [];
+    if (text === null) checks.push({ ok: false, level: "warn", message: `Cursor: ${RULE_FILE} not found` });
+    else if (!/^---[\s\S]*?alwaysApply:\s*true[\s\S]*?---/.test(text)) checks.push({ ok: false, level: "warn", message: `Cursor: ${RULE_FILE} frontmatter was modified (alwaysApply is not true)` });
+    else checks.push({ ok: true, level: "ok", message: `Cursor: ${RULE_FILE}` });
+    const hooks = await readTextIfExists(path3.join(root, HOOKS_FILE));
+    if (hooks === null) checks.push({ ok: false, level: "warn", message: `Cursor: ${HOOKS_FILE} not found \u2014 activity reporting is off` });
+    else if (!hooks.includes("--athena-hook")) checks.push({ ok: false, level: "warn", message: `Cursor: no Athena hooks in ${HOOKS_FILE}` });
+    else checks.push({ ok: true, level: "ok", message: `Cursor: activity hooks installed (${CURSOR_HOOK_EVENTS.length} events)` });
+    return checks;
+  }
+};
+
+// src/agents/antigravity/adapter.ts
+import path4 from "path";
+var RULE_FILE2 = ".agents/rules/athena.md";
+var ANTIGRAVITY_RULE_LIMIT = 12e3;
+var antigravityAdapter = {
+  id: "antigravity",
+  displayName: "Antigravity",
+  capabilities: { instructionsFile: true, scopedRules: true, hooks: false, mcp: true },
+  supportNote: 'Uses an Athena-owned workspace rule at .agents/rules/athena.md. Set its activation to "Always On" in Antigravity if it is not applied automatically.',
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { dirs: [".agents", ".agent"], athenaOwned: [RULE_FILE2] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const content = [OWNED_HEADER, "", athenaInstructions({ heading: "#" }), ""].join("\n");
+    if (content.length > ANTIGRAVITY_RULE_LIMIT) throw new Error(`Antigravity rule exceeds ${ANTIGRAVITY_RULE_LIMIT} characters`);
+    return [await planOwned(ctx.root, RULE_FILE2, content)];
+  },
+  async remove(root) {
+    return await removeOwned(root, RULE_FILE2) ? [RULE_FILE2] : [];
+  },
+  async check(root) {
+    const text = await readTextIfExists(path4.join(root, RULE_FILE2));
+    if (text === null) return [{ ok: false, level: "warn", message: `Antigravity: ${RULE_FILE2} not found` }];
+    if (text.length > ANTIGRAVITY_RULE_LIMIT) return [{ ok: false, level: "error", message: `Antigravity: ${RULE_FILE2} exceeds the 12,000 character rule limit` }];
+    return [
+      { ok: true, level: "ok", message: `Antigravity: ${RULE_FILE2}` },
+      { ok: true, level: "warn", message: 'Antigravity: activation mode cannot be verified from files \u2014 confirm the rule is "Always On" in Antigravity' }
+    ];
+  }
+};
+
+// src/agents/codex/adapter.ts
+import { promises as fs3 } from "fs";
+import os from "os";
+import path5 from "path";
+import { parse as parseToml } from "smol-toml";
+var INSTRUCTIONS = "AGENTS.md";
+var CONFIG = ".codex/config.toml";
+var HOOKS_FILE2 = ".codex/hooks.json";
+var TOML_START = "# athena:start (managed by Athena; `athena agents remove codex` removes it)";
+var TOML_END = "# athena:end";
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: true, mcp: true },
+  supportNote: "Uses the Athena block in AGENTS.md, an MCP server entry in .codex/config.toml, and hooks in .codex/hooks.json that report activity. Codex loads .codex/ only for trusted projects.",
+  async detectPresence(root) {
+    const athenaOwned = await tomlOnlyAthena(path5.join(root, CONFIG)) ? [CONFIG] : [];
+    const evidence = await userEvidence(root, { dirs: [".codex"], athenaOwned, athenaOwnedJson: [HOOKS_FILE2] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const changes = [await planBlock(ctx.root, INSTRUCTIONS, athenaInstructions({ heading: "##" }))];
+    changes.push(await planConfig(ctx.root));
+    changes.push(
+      await planJsonChange(ctx.root, HOOKS_FILE2, (data) => {
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of CODEX_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({ hooks: [{ type: "command", command: codexHookCommand(event), timeout: 10 }] });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeBlockFrom(root, INSTRUCTIONS)) touched.push(INSTRUCTIONS);
+    if (await removeConfigBlock(root)) touched.push(CONFIG);
+    const removed = await removeJsonHooks(
+      root,
+      HOOKS_FILE2,
+      (data) => {
+        const hooks = data.hooks;
+        if (!hooks) return;
+        for (const event of Object.keys(hooks)) {
+          hooks[event] = (hooks[event] ?? []).filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+      },
+      (data) => Object.keys(data).length === 0
+    );
+    if (removed) touched.push(HOOKS_FILE2);
+    return touched;
+  },
+  async check(root) {
+    const checks = [await checkBlock(root, INSTRUCTIONS, "Codex")];
+    const config = await readTextIfExists(path5.join(root, CONFIG));
+    checks.push(
+      config?.includes(TOML_START) && config.includes("[mcp_servers.athena]") ? { ok: true, level: "ok", message: `Codex: MCP server registered in ${CONFIG}` } : { ok: false, level: "warn", message: `Codex: no Athena MCP entry in ${CONFIG} \u2014 re-run \`athena agents add codex\`` }
+    );
+    const hooks = await readTextIfExists(path5.join(root, HOOKS_FILE2));
+    if (hooks === null) checks.push({ ok: false, level: "warn", message: `Codex: ${HOOKS_FILE2} not found \u2014 activity reporting is off` });
+    else {
+      const configured = CODEX_HOOK_EVENTS.filter((e) => new RegExp(`"${e}"`).test(hooks) && hooks.includes(ATHENA_MARK));
+      checks.push(
+        configured.length === CODEX_HOOK_EVENTS.length ? { ok: true, level: "ok", message: `Codex: activity hooks installed (${configured.length} events)` } : { ok: false, level: "warn", message: `Codex: only ${configured.length}/${CODEX_HOOK_EVENTS.length} activity hooks installed \u2014 re-run \`athena agents add codex\`` }
+      );
+    }
+    checks.push(await trustCheck(root));
+    return checks;
+  }
+};
+function codexHookCommand(event) {
+  const cmd = hookCommand();
+  const exe = /[\s"'$`\\]/.test(cmd) ? JSON.stringify(cmd) : cmd;
+  return `${exe} event ${ATHENA_MARK} --agent codex --hook ${event}`;
+}
+function mcpBlock() {
+  return [TOML_START, "[mcp_servers.athena]", `command = ${JSON.stringify(hookCommand())}`, 'args = ["mcp"]', TOML_END].join("\n");
+}
+function stripTomlBlock(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let inside = false;
+  for (const line of lines) {
+    if (!inside && line.startsWith("# athena:start")) inside = true;
+    else if (inside && line.trim() === TOML_END) inside = false;
+    else if (!inside) out.push(line);
+  }
+  return out.join("\n");
+}
+function parseTomlOrThrow(text) {
+  try {
+    return parseToml(text);
+  } catch {
+    throw new Error(`${CONFIG} is not valid TOML \u2014 fix it before configuring Codex`);
+  }
+}
+async function planConfig(root) {
+  const existing = await readTextIfExists(path5.join(root, CONFIG));
+  const base = existing === null ? "" : stripTomlBlock(existing);
+  const parsed = parseTomlOrThrow(base);
+  const servers = parsed.mcp_servers;
+  if (servers && "athena" in servers) return { path: CONFIG, ownership: "block", action: "unchanged", content: existing ?? "" };
+  const head = base.trimEnd();
+  const content = `${head ? `${head}
+
+` : ""}${mcpBlock()}
+`;
+  return { path: CONFIG, ownership: "block", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
+}
+async function removeConfigBlock(root) {
+  const file = path5.join(root, CONFIG);
+  const existing = await readTextIfExists(file);
+  if (existing === null || !existing.includes(TOML_START)) return false;
+  const next = stripTomlBlock(existing).trimEnd();
+  if (next.trim() === "") await fs3.rm(file, { force: true });
+  else await fs3.writeFile(file, `${next}
+`, "utf8");
+  return true;
+}
+async function tomlOnlyAthena(file) {
+  const text = await readTextIfExists(file).catch(() => null);
+  return text !== null && text.includes(TOML_START) && stripTomlBlock(text).trim() === "";
+}
+async function trustCheck(root) {
+  const home = process.env.CODEX_HOME?.trim() || path5.join(os.homedir(), ".codex");
+  const hint = `Codex loads .codex/ only for trusted projects: trust this folder when Codex asks, or add [projects."${root}"] trust_level = "trusted" to ${path5.join(home, "config.toml")}`;
+  const text = await readTextIfExists(path5.join(home, "config.toml")).catch(() => null);
+  if (text === null) return { ok: false, level: "warn", message: `Codex: could not confirm this project is trusted. ${hint}` };
+  let projects = {};
+  try {
+    projects = parseToml(text).projects ?? {};
+  } catch {
+    return { ok: false, level: "warn", message: `Codex: could not read ${path5.join(home, "config.toml")} to confirm trust. ${hint}` };
+  }
+  for (let dir = root; ; dir = path5.dirname(dir)) {
+    const entry = projects[dir];
+    if (entry?.trust_level === "trusted") return { ok: true, level: "ok", message: `Codex: project is trusted${dir === root ? "" : ` (via ${dir})`}` };
+    if (entry?.trust_level === "untrusted") return { ok: false, level: "warn", message: `Codex: ${dir} is marked untrusted, so Codex ignores .codex/. ${hint}` };
+    if (path5.dirname(dir) === dir) break;
+  }
+  return { ok: false, level: "warn", message: `Codex: this project is not trusted yet. ${hint}` };
+}
+
+// src/agents/copilot/adapter.ts
+import { promises as fs4 } from "fs";
+import path6 from "path";
+var INSTRUCTIONS2 = ".github/copilot-instructions.md";
+var MCP_FILE3 = ".vscode/mcp.json";
+var HOOKS_DIR = ".github/hooks";
+var HOOKS_FILE3 = `${HOOKS_DIR}/athena.json`;
+var copilotAdapter = {
+  id: "copilot",
+  displayName: "GitHub Copilot",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: true, mcp: true },
+  supportNote: "Uses the Athena block in .github/copilot-instructions.md, an MCP server entry in .vscode/mcp.json (VS Code), and hooks in .github/hooks/athena.json that report activity (VS Code hooks are in Preview; Copilot CLI reads the same file).",
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [INSTRUCTIONS2], dirs: [".github/instructions", HOOKS_DIR], athenaOwnedJson: [HOOKS_FILE3] });
+    if (await exists(path6.join(root, MCP_FILE3)) && !await jsonOnlyAthena(path6.join(root, MCP_FILE3))) evidence.push(MCP_FILE3);
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const changes = [await planBlock(ctx.root, INSTRUCTIONS2, athenaInstructions({ heading: "##" }))];
+    changes.push(
+      await planJsonChange(ctx.root, MCP_FILE3, (data) => {
+        const servers = data.servers && typeof data.servers === "object" && !Array.isArray(data.servers) ? data.servers : {};
+        servers.athena = { type: "stdio", command: hookCommand(), args: ["mcp"] };
+        data.servers = servers;
+      })
+    );
+    changes.push(
+      await planJsonChange(ctx.root, HOOKS_FILE3, (data) => {
+        data.version = typeof data.version === "number" ? data.version : 1;
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of COPILOT_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({ type: "command", bash: posixCommand(event), powershell: powershellCommand(event), timeoutSec: 10 });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeBlockFrom(root, INSTRUCTIONS2)) touched.push(INSTRUCTIONS2);
+    const mcpRemoved = await removeJsonHooks(
+      root,
+      MCP_FILE3,
+      (data) => {
+        const servers = data.servers;
+        if (!servers || typeof servers !== "object") return;
+        delete servers.athena;
+        pruneEmpty(data, "servers");
+      },
+      (d) => Object.keys(d).length === 0
+    );
+    if (mcpRemoved) touched.push(MCP_FILE3);
+    const hooksRemoved = await removeJsonHooks(
+      root,
+      HOOKS_FILE3,
+      (data) => {
+        const hooks = data.hooks;
+        if (!hooks || typeof hooks !== "object") return;
+        for (const event of Object.keys(hooks)) {
+          if (!Array.isArray(hooks[event])) continue;
+          hooks[event] = hooks[event].filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+        if (Object.keys(data).length === 1 && "version" in data) delete data.version;
+      },
+      (d) => Object.keys(d).length === 0
+    );
+    if (hooksRemoved) touched.push(HOOKS_FILE3);
+    for (const dir of [HOOKS_DIR, ".vscode"]) await fs4.rmdir(path6.join(root, dir)).catch(() => {
+    });
+    return touched;
+  },
+  async check(root) {
+    const checks = [await checkBlock(root, INSTRUCTIONS2, "GitHub Copilot")];
+    const mcp = await readJsonFile(path6.join(root, MCP_FILE3)).catch(() => null);
+    const servers = mcp?.data.servers;
+    if (mcp?.malformed) checks.push({ ok: false, level: "error", message: `GitHub Copilot: ${MCP_FILE3} is not valid JSON` });
+    else
+      checks.push(
+        servers && typeof servers === "object" && "athena" in servers ? { ok: true, level: "ok", message: `GitHub Copilot: MCP server registered in ${MCP_FILE3} (VS Code)` } : { ok: false, level: "warn", message: `GitHub Copilot: no Athena MCP entry in ${MCP_FILE3} \u2014 re-run \`athena agents add copilot\`` }
+      );
+    const hooks = await readTextIfExists(path6.join(root, HOOKS_FILE3));
+    if (hooks === null) checks.push({ ok: false, level: "warn", message: `GitHub Copilot: ${HOOKS_FILE3} not found \u2014 activity reporting is off` });
+    else {
+      const configured = COPILOT_HOOK_EVENTS.filter((e) => new RegExp(`"${e}"`).test(hooks) && hooks.includes(ATHENA_MARK));
+      checks.push(
+        configured.length === COPILOT_HOOK_EVENTS.length ? { ok: true, level: "ok", message: `GitHub Copilot: activity hooks installed (${configured.length} events)` } : { ok: false, level: "warn", message: `GitHub Copilot: only ${configured.length}/${COPILOT_HOOK_EVENTS.length} activity hooks installed \u2014 re-run \`athena agents add copilot\`` }
+      );
+    }
+    return checks;
+  }
+};
+function posixCommand(event) {
+  const cmd = hookCommand();
+  const exe = /[\s"'$`\\]/.test(cmd) ? `'${cmd.replace(/'/g, `'\\''`)}'` : cmd;
+  return `${exe} event ${ATHENA_MARK} --agent copilot --hook ${event} 2>/dev/null || true`;
+}
+function powershellCommand(event) {
+  const exe = `'${hookCommand().replace(/'/g, "''")}'`;
+  return `& ${exe} event ${ATHENA_MARK} --agent copilot --hook ${event} 2>$null; exit 0`;
+}
+
+// src/agents/gemini-cli/adapter.ts
+import { promises as fs5 } from "fs";
+import path7 from "path";
+var CONTEXT = "GEMINI.md";
+var SETTINGS2 = ".gemini/settings.json";
+var geminiCliAdapter = {
+  id: "gemini-cli",
+  displayName: "Gemini CLI",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: true, mcp: true },
+  supportNote: "Uses the Athena block in GEMINI.md, plus an MCP server entry and hooks that report activity in .gemini/settings.json. Gemini CLI ignores .gemini/settings.json in folders it does not trust (when folder trust is enabled).",
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [CONTEXT], dirs: [".gemini"], athenaOwnedJson: [SETTINGS2] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const changes = [await planBlock(ctx.root, CONTEXT, athenaInstructions({ heading: "##" }))];
+    changes.push(
+      await planJsonChange(ctx.root, SETTINGS2, (data) => {
+        mergeMcpServers(data);
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of GEMINI_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({
+            ...event === "BeforeTool" ? { matcher: "*" } : {},
+            hooks: [{ name: "athena-activity", type: "command", command: geminiHookCommand(event), timeout: 1e4 }]
+          });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeBlockFrom(root, CONTEXT)) touched.push(CONTEXT);
+    const removed = await removeJsonHooks(
+      root,
+      SETTINGS2,
+      (data) => {
+        stripMcpServers(data);
+        const hooks = data.hooks;
+        if (!hooks || typeof hooks !== "object") return;
+        for (const event of Object.keys(hooks)) {
+          if (!Array.isArray(hooks[event])) continue;
+          hooks[event] = hooks[event].filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+      },
+      (d) => Object.keys(d).length === 0
+    );
+    if (removed) touched.push(SETTINGS2);
+    await fs5.rmdir(path7.join(root, ".gemini")).catch(() => {
+    });
+    return touched;
+  },
+  async check(root) {
+    const checks = [await checkBlock(root, CONTEXT, "Gemini CLI")];
+    const settings = await readJsonFile(path7.join(root, SETTINGS2)).catch(() => null);
+    if (!settings?.existed) {
+      checks.push({ ok: false, level: "warn", message: `Gemini CLI: ${SETTINGS2} not found \u2014 no MCP server and activity reporting is off` });
+      return checks;
+    }
+    if (settings.malformed) {
+      checks.push({ ok: false, level: "error", message: `Gemini CLI: ${SETTINGS2} is not valid JSON` });
+      return checks;
+    }
+    const servers = settings.data.mcpServers;
+    checks.push(
+      servers && typeof servers === "object" && "athena" in servers ? { ok: true, level: "ok", message: `Gemini CLI: MCP server registered in ${SETTINGS2}` } : { ok: false, level: "warn", message: `Gemini CLI: no Athena MCP entry in ${SETTINGS2} \u2014 re-run \`athena agents add gemini-cli\`` }
+    );
+    const text = await readTextIfExists(path7.join(root, SETTINGS2)) ?? "";
+    const hooks = settings.data.hooks ?? {};
+    const configured = GEMINI_HOOK_EVENTS.filter((e) => isAthenaEntry(hooks[e]));
+    checks.push(
+      configured.length === GEMINI_HOOK_EVENTS.length && text.includes(ATHENA_MARK) ? { ok: true, level: "ok", message: `Gemini CLI: activity hooks installed (${configured.length} events)` } : { ok: false, level: "warn", message: `Gemini CLI: only ${configured.length}/${GEMINI_HOOK_EVENTS.length} activity hooks installed \u2014 re-run \`athena agents add gemini-cli\`` }
+    );
+    checks.push({ ok: true, level: "warn", message: "Gemini CLI: if folder trust is enabled, trust this folder \u2014 Gemini CLI ignores .gemini/settings.json (MCP, hooks) in untrusted folders" });
+    return checks;
+  }
+};
+function geminiHookCommand(event) {
+  const cmd = hookCommand();
+  const exe = /[\s"'$`\\]/.test(cmd) ? JSON.stringify(cmd) : cmd;
+  return `${exe} event ${ATHENA_MARK} --agent gemini-cli --hook ${event}`;
+}
+
+// src/agents/windsurf/adapter.ts
+import path8 from "path";
+var RULE_FILE3 = ".windsurf/rules/athena.md";
+var WINDSURF_RULE_LIMIT = 12e3;
+var windsurfAdapter = {
+  id: "windsurf",
+  displayName: "Windsurf",
+  capabilities: { instructionsFile: true, scopedRules: true, hooks: false, mcp: false },
+  supportNote: 'Uses an Athena-owned workspace rule at .windsurf/rules/athena.md (trigger: always_on), which Windsurf and Devin Desktop read. MCP is configured per user in Windsurf, so Athena does not register it: add `{ "mcpServers": { "athena": { "command": "athena", "args": ["mcp"] } } }` to your mcp_config.json yourself. No activity hooks.',
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [".windsurfrules"], dirs: [".windsurf"], athenaOwned: await generatedByAthena(root, [RULE_FILE3]) });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const content = ["---", "trigger: always_on", "---", OWNED_HEADER, "", athenaInstructions({ heading: "#" }), ""].join("\n");
+    if (content.length > WINDSURF_RULE_LIMIT) throw new Error(`Windsurf rule exceeds ${WINDSURF_RULE_LIMIT} characters`);
+    return [await planOwned(ctx.root, RULE_FILE3, content)];
+  },
+  async remove(root) {
+    return await removeOwned(root, RULE_FILE3) ? [RULE_FILE3] : [];
+  },
+  async check(root) {
+    const text = await readTextIfExists(path8.join(root, RULE_FILE3));
+    if (text === null) return [{ ok: false, level: "warn", message: `Windsurf: ${RULE_FILE3} not found` }];
+    if (!text.includes("Generated by Athena")) return [{ ok: false, level: "warn", message: `Windsurf: ${RULE_FILE3} is a developer file, so Athena did not write its rule there` }];
+    const checks = [];
+    if (text.length > WINDSURF_RULE_LIMIT) checks.push({ ok: false, level: "error", message: `Windsurf: ${RULE_FILE3} exceeds the 12,000 character rule limit` });
+    else if (!/^---\r?\n[\s\S]*?trigger:\s*always_on[\s\S]*?\r?\n---/.test(text)) checks.push({ ok: false, level: "warn", message: `Windsurf: ${RULE_FILE3} frontmatter was modified (trigger is not always_on)` });
+    else checks.push({ ok: true, level: "ok", message: `Windsurf: ${RULE_FILE3}` });
+    return checks;
+  }
+};
+async function generatedByAthena(root, rels) {
+  const out = [];
+  for (const rel of rels) {
+    const text = await readTextIfExists(path8.join(root, rel)).catch(() => null);
+    if (text?.includes("Generated by Athena")) out.push(rel);
+  }
+  return out;
+}
+
+// src/agents/cline/adapter.ts
+import { promises as fs6 } from "fs";
+import path9 from "path";
+var RULES_DIR = ".clinerules";
+var RULE_FILE4 = ".clinerules/athena.md";
+var ALT_RULE_FILE = ".cline/rules/athena.md";
+var clineAdapter = {
+  id: "cline",
+  displayName: "Cline",
+  capabilities: { instructionsFile: true, scopedRules: true, hooks: false, mcp: false },
+  supportNote: 'Uses an Athena-owned workspace rule at .clinerules/athena.md (or .cline/rules/athena.md when .clinerules is a single file). MCP servers are configured per user in Cline, so Athena does not register it: add an "athena" server with command `athena` and args ["mcp"] in Cline\'s MCP settings yourself. No activity hooks.',
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [RULES_DIR], dirs: [RULES_DIR, ".cline"], athenaOwned: await generatedByAthena2(root, [RULE_FILE4, ALT_RULE_FILE]) });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const content = [OWNED_HEADER, "", athenaInstructions({ heading: "#" }), ""].join("\n");
+    return [await planOwned(ctx.root, await rulePath(ctx.root), content)];
+  },
+  async remove(root) {
+    const touched = [];
+    for (const rel of [RULE_FILE4, ALT_RULE_FILE]) {
+      if (!await isDirectory(path9.join(root, path9.dirname(rel)))) continue;
+      if (await removeOwned(root, rel)) touched.push(rel);
+    }
+    return touched;
+  },
+  async check(root) {
+    const rel = await rulePath(root);
+    const text = await readTextIfExists(path9.join(root, rel));
+    if (text === null) return [{ ok: false, level: "warn", message: `Cline: ${rel} not found` }];
+    if (!text.includes("Generated by Athena")) return [{ ok: false, level: "warn", message: `Cline: ${rel} is a developer file, so Athena did not write its rule there` }];
+    const checks = [{ ok: true, level: "ok", message: `Cline: ${rel}` }];
+    if (rel === ALT_RULE_FILE && !await isDirectory(path9.join(root, RULES_DIR)) && await exists2(path9.join(root, RULES_DIR))) {
+      checks.push({ ok: true, level: "warn", message: `Cline: .clinerules is a single file, so Athena's rule is in ${ALT_RULE_FILE}; older Cline versions that only read .clinerules will not see it` });
+    }
+    return checks;
+  }
+};
+async function rulePath(root) {
+  const clinerules = path9.join(root, RULES_DIR);
+  if (await exists2(clinerules) && !await isDirectory(clinerules)) return ALT_RULE_FILE;
+  const alt = await readTextIfExists(path9.join(root, ALT_RULE_FILE)).catch(() => null);
+  if (alt?.includes("Generated by Athena")) return ALT_RULE_FILE;
+  return RULE_FILE4;
+}
+async function exists2(p) {
+  return await fs6.lstat(p).catch(() => null) !== null;
+}
+async function isDirectory(p) {
+  return (await fs6.lstat(p).catch(() => null))?.isDirectory() ?? false;
+}
+async function generatedByAthena2(root, rels) {
+  const out = [];
+  for (const rel of rels) {
+    const text = await readTextIfExists(path9.join(root, rel)).catch(() => null);
+    if (text?.includes("Generated by Athena")) out.push(rel);
+  }
+  return out;
+}
+
+// src/agents/agents-md/adapter.ts
+var agentsMdAdapter = {
+  id: "agents-md",
+  displayName: "AGENTS.md (cross-agent)",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: false, mcp: false },
+  supportNote: "Manages a marked block in AGENTS.md for agents that read the AGENTS.md convention.",
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: ["AGENTS.md"] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    return [await planBlock(ctx.root, "AGENTS.md", athenaInstructions({ heading: "##" }))];
+  },
+  async remove(root) {
+    return await removeBlockFrom(root, "AGENTS.md") ? ["AGENTS.md"] : [];
+  },
+  async check(root) {
+    return [await checkBlock(root, "AGENTS.md", "AGENTS.md")];
+  }
+};
+
+// src/agents/registry.ts
+var ADAPTERS = [claudeCodeAdapter, cursorAdapter, codexAdapter, copilotAdapter, geminiCliAdapter, antigravityAdapter, windsurfAdapter, clineAdapter, agentsMdAdapter];
+function resolveAdapters(names) {
+  const alias = {
+    claude: "claude-code",
+    claudecode: "claude-code",
+    agents: "agents-md",
+    "agents.md": "agents-md",
+    gemini: "gemini-cli",
+    geminicli: "gemini-cli",
+    "openai-codex": "codex",
+    "codex-cli": "codex",
+    "github-copilot": "copilot",
+    "gh-copilot": "copilot",
+    "copilot-cli": "copilot",
+    "google-antigravity": "antigravity",
+    codeium: "windsurf"
+  };
+  const out = [];
+  for (const raw of names) {
+    const n = raw.trim().toLowerCase();
+    if (!n) continue;
+    const id = alias[n] ?? n;
+    const a = ADAPTERS.find((x) => x.id === id);
+    if (!a) throw new Error(`Unknown agent "${raw}". Supported: ${ADAPTERS.map((x) => x.id).join(", ")}`);
+    if (!out.includes(a)) out.push(a);
+  }
+  return out;
+}
+async function applyChanges(root, changes) {
+  const applied = [];
+  for (const c of changes) {
+    if (c.action === "unchanged") continue;
+    const abs = resolveInside(root, c.path);
+    if (!abs) throw new Error(`Refusing to write outside the project: ${c.path}`);
+    const st = await fs7.lstat(abs).catch(() => null);
+    if (st?.isSymbolicLink()) throw new Error(`Refusing to write through symlink: ${c.path}`);
+    await fs7.mkdir(path10.dirname(abs), { recursive: true });
+    await writeFileAtomic(abs, c.content);
+    if (abs.endsWith(".sh")) await fs7.chmod(abs, 493).catch(() => {
+    });
+    applied.push(c);
+  }
+  return applied;
+}
+
+export {
+  ADAPTERS,
+  resolveAdapters,
+  applyChanges
+};
+//# sourceMappingURL=chunk-YRIS7ZS6.js.map