@amsterdamdatalabs/enact-extensions 0.1.0 → 0.1.1

package/scripts/hooks/session-start-drift-check.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * session-start-drift-check.mjs — Enact Extensions session-start drift hook.
+ *
+ * Registered as a session-start hook for Claude, Codex, Cursor, and Enact.
+ * Checks whether any installed enact-extensions plugins have drifted from
+ * their canonical source (i.e. are outdated) and prints a concise advisory
+ * if so.
+ *
+ * Design constraints:
+ *   - FAIL-SILENT: wrap everything in try/catch; never throw; always exit 0.
+ *   - FAST: imports computeOutdated directly (no subprocess) for speed.
+ *   - READ-ONLY: never writes any state.
+ *   - NO OUTPUT on success (or error): only print when there are outdated entries.
+ *   - DEPENDENCY-FREE: only node builtins + enact-extensions own modules.
+ */
+
+import { dirname, resolve, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Navigate from scripts/hooks/ up to the repo root so we can import lib modules.
+const REPO_ROOT = resolve(__dirname, "..", "..");
+
+try {
+  // Dynamically import so any module-load failure is caught by the outer try/catch.
+  const { computeOutdated } = await import(join(REPO_ROOT, "scripts", "lib", "outdated.mjs"));
+
+  let entries;
+  try {
+    entries = computeOutdated();
+  } catch {
+    // computeOutdated threw (ledger missing, I/O error, etc.) — stay silent.
+    process.exit(0);
+  }
+
+  // Filter to only outdated entries (not fresh, not orphaned).
+  const outdated = (entries ?? []).filter((e) => e && e.status === "outdated");
+
+  if (outdated.length === 0) {
+    // Nothing to report.
+    process.exit(0);
+  }
+
+  // Build a concise list of (plugin, surface) pairs.
+  const pairs = outdated
+    .map((e) => `${e.name}/${e.platform}`)
+    .join(", ");
+
+  // Single advisory line to stdout.
+  process.stdout.write(
+    `[enact-extensions] ${outdated.length} plugin surface${outdated.length === 1 ? "" : "s"} outdated: ${pairs}. Run: enact-extensions update --all\n`,
+  );
+} catch {
+  // Any top-level error (import failure, parse error, etc.) — silent exit 0.
+}
+
+process.exit(0);

package/scripts/lib/build-index.mjs

@@ -0,0 +1,50 @@
+import { relative } from "node:path";
+import { listBundles } from "./list-bundles.mjs";
+
+/**
+ * Build a discovery index of all plugin bundles.
+ *
+ * The index is a generated artifact — it is NEVER committed. The schema
+ * contract lives in spec/index.json.
+ *
+ * @param {string[]} roots         - Absolute paths to scan for plugin bundles
+ *                                   (passed directly to listBundles).
+ * @param {object}  [opts]
+ * @param {string|null} [opts.now] - ISO timestamp to stamp on generatedAt.
+ *                                   Pass a fixed value for deterministic tests.
+ *                                   Defaults to null when omitted — this lib is
+ *                                   pure and never calls new Date(). The CLI
+ *                                   boundary computes the live timestamp and
+ *                                   passes it in as `now`.
+ * @param {string}  [opts.packageRoot] - Absolute package root used to compute
+ *                                       repo-relative paths. Defaults to the
+ *                                       directory two levels above this file.
+ * @returns {{ generatedAt: string|null, count: number, plugins: object[] }}
+ */
+export function buildIndex(roots, opts = {}) {
+  const { now = null, packageRoot } = opts;
+
+  // Resolve package root: two levels up from this file (scripts/lib/ → repo root)
+  const pkgRoot =
+    packageRoot ??
+    new URL("../../", import.meta.url).pathname.replace(/\/$/, "");
+
+  // Source bundles via the canonical list-bundles helper (deduplicated, resilient).
+  const entries = listBundles(roots);
+
+  const plugins = entries.map((entry) => ({
+    name: entry.name,
+    version: entry.version,
+    category: entry.category,
+    description: entry.description,
+    targets: entry.targets,
+    // Make path repo-relative so the artifact is portable.
+    path: relative(pkgRoot, entry.path),
+  }));
+
+  return {
+    generatedAt: now,
+    count: plugins.length,
+    plugins,
+  };
+}

package/scripts/lib/bundle-hash.mjs

@@ -0,0 +1,137 @@
+/**
+ * bundle-hash.mjs — deterministic content hash for a plugin bundle.
+ *
+ * bundleHash(pluginRoot) → sha256 hex string
+ *
+ * The hash covers the CANONICAL bundle content only:
+ *   - .agents/plugin.json (the manifest itself)
+ *   - Component dirs/files referenced in the manifest:
+ *       skills, mcpServers, apps, commands, hooks, agents, _agents, rules
+ *   - .mcp.json (if present at pluginRoot root)
+ *
+ * EXCLUDED (generated / derived surfaces, never present in canonical source):
+ *   - .claude-plugin/
+ *   - .codex-plugin/
+ *   - .cursor-plugin/
+ *
+ * Algorithm:
+ *   1. Collect the set of paths to include (manifest + referenced component paths).
+ *   2. Walk each path recursively; collect all (relativePath, bytes) pairs.
+ *   3. Sort by relative path (order-independence).
+ *   4. Feed path + bytes for each file into a single sha256 digest.
+ *   5. Return the hex digest.
+ *
+ * Pure, no writes, synchronous.
+ */
+
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Canonical component field names (mirrors pathFieldsFromManifest in install.ts)
+// ---------------------------------------------------------------------------
+const COMPONENT_FIELDS = [
+  "skills",
+  "mcpServers",
+  "apps",
+  "commands",
+  "hooks",
+  "agents",
+  "_agents",
+  "rules",
+];
+
+// Generated platform dirs — always excluded from the canonical hash.
+const EXCLUDED_DIRS = new Set([".claude-plugin", ".codex-plugin", ".cursor-plugin"]);
+
+/**
+ * Recursively collect all file entries under `root`.
+ * Returns an array of { rel: string, abs: string } sorted by rel.
+ * Silently skips non-file, non-directory entries.
+ *
+ * @param {string} abs - absolute path to walk
+ * @param {string} base - the pluginRoot (for computing relative paths)
+ * @param {string[]} acc - accumulator
+ */
+function walkFiles(abs, base, acc) {
+  if (!existsSync(abs)) return;
+  const stat = statSync(abs);
+  if (stat.isFile()) {
+    acc.push(relative(base, abs));
+    return;
+  }
+  if (!stat.isDirectory()) return;
+  const entries = readdirSync(abs).sort(); // sort for determinism
+  for (const name of entries) {
+    walkFiles(join(abs, name), base, acc);
+  }
+}
+
+/**
+ * Collect the canonical set of relative paths to include in the hash.
+ *
+ * @param {string} pluginRoot
+ * @param {object} manifest - parsed .agents/plugin.json
+ * @returns {string[]} sorted relative paths (relative to pluginRoot)
+ */
+function canonicalPaths(pluginRoot, manifest) {
+  // Always include the manifest itself.
+  const collected = [];
+
+  // 1. Always walk .agents/plugin.json (the manifest).
+  walkFiles(join(pluginRoot, ".agents", "plugin.json"), pluginRoot, collected);
+
+  // 2. Walk each component path that exists.
+  for (const field of COMPONENT_FIELDS) {
+    const raw = manifest[field];
+    if (typeof raw !== "string" || !raw.trim()) continue;
+    // Normalise: strip leading ./ and trailing /
+    const cleaned = raw.replace(/^\.\//, "").replace(/\/+$/, "");
+    if (!cleaned || cleaned.startsWith("../")) continue;
+    // Refuse to hash generated platform dirs even if the manifest references them.
+    const topSegment = cleaned.split("/")[0];
+    if (EXCLUDED_DIRS.has(topSegment)) continue;
+    walkFiles(join(pluginRoot, cleaned), pluginRoot, collected);
+  }
+
+  // 3. .mcp.json at pluginRoot root (included if present, regardless of manifest field)
+  walkFiles(join(pluginRoot, ".mcp.json"), pluginRoot, collected);
+
+  // Sort for order-independence, then deduplicate.
+  const unique = [...new Set(collected)].sort();
+  return unique;
+}
+
+/**
+ * Compute a deterministic sha256 hex hash of the canonical plugin bundle.
+ *
+ * @param {string} pluginRoot - absolute path to the bundle root
+ * @returns {string} sha256 hex digest (64 lowercase hex chars)
+ * @throws {Error} if the manifest cannot be read (ENOENT, parse error, etc.)
+ */
+export function bundleHash(pluginRoot) {
+  // Read and parse the manifest first — this is the anchor; if it's missing
+  // we cannot know which component paths to include, so we throw.
+  const manifestPath = join(pluginRoot, ".agents", "plugin.json");
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Cannot compute bundle hash: manifest not found at ${manifestPath}`);
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+  // Collect the sorted list of relative paths.
+  const paths = canonicalPaths(pluginRoot, manifest);
+
+  // Hash all paths and their contents in sorted order.
+  const hash = createHash("sha256");
+  for (const rel of paths) {
+    const abs = join(pluginRoot, rel);
+    // Feed the relative path as a NUL-terminated string to make path changes
+    // visible even when content is identical.
+    hash.update(rel + "\0", "utf8");
+    // Feed the file bytes.
+    hash.update(readFileSync(abs));
+  }
+
+  return hash.digest("hex");
+}

package/scripts/lib/hooks.mjs

@@ -0,0 +1,389 @@
+/**
+ * hooks.mjs — Drift-check hook registration logic for all surfaces.
+ *
+ * Supports: claude, codex, cursor, enact
+ *
+ * Per-surface registration details:
+ *
+ * CLAUDE:
+ *   Writes to <claudeHome>/settings.json (creates/merges JSON).
+ *   Adds a `hooks.SessionStart` array entry with a command that invokes the
+ *   drift-check script via `node <abs path>`. Idempotent (keyed by a stable
+ *   marker string in the command). This matches the Claude Code hook format:
+ *   https://docs.anthropic.com/en/docs/claude-code/hooks
+ *
+ * CODEX / ENACT:
+ *   Writes to <home>/config.toml.
+ *   Adds a `[[hooks.session_start]]` entry. The codex-fork's exact TOML hook
+ *   schema is approximated from the enact-agent config conventions. The entry
+ *   is clearly namespaced (`[hooks]` / `[[hooks.session_start]]`) and is
+ *   idempotent (guarded by a stable comment marker). If the exact schema is
+ *   different in a given codex/enact build, the TOML entry is still safe to
+ *   have present (unknown sections are ignored by most TOML parsers).
+ *
+ * CURSOR:
+ *   Cursor uses a settings.json at <cursorHome>/settings.json, similar to
+ *   Claude. Registration mirrors the claude approach (SessionStart hooks array).
+ *   If Cursor's actual hook schema differs, the entry is still reversible and
+ *   clearly marked.
+ *
+ * All registrations are IDEMPOTENT (safe to run twice) and REVERSIBLE
+ * (--remove cleanly undoes them).
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const REPO_ROOT = resolve(__dirname, "..", "..");
+
+// Absolute path to the drift-check hook script.
+const DRIFT_CHECK_SCRIPT = join(REPO_ROOT, "scripts", "hooks", "session-start-drift-check.mjs");
+
+// Stable marker used to detect an existing entry (idempotency key).
+const CLAUDE_HOOK_MARKER = "enact-extensions:session-start-drift-check";
+const TOML_HOOK_MARKER = "enact-extensions:session-start-drift-check";
+
+// ---------------------------------------------------------------------------
+// Default home paths per surface
+// ---------------------------------------------------------------------------
+function defaultHome(surface) {
+  const home = homedir();
+  switch (surface) {
+    case "claude": return join(home, ".claude");
+    case "codex":  return join(home, ".codex");
+    case "enact":  return join(home, ".enact", "agent");
+    case "cursor": return join(home, ".cursor");
+    default:       throw new Error(`Unknown surface: ${surface}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Claude settings.json helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the SessionStart hook entry object for Claude's settings.json.
+ * The command invokes node directly with the absolute hook script path.
+ *
+ * Claude Code hook format (from docs + live ~/.claude/settings.json):
+ *   { matcher: ".*", hooks: [{ type: "command", command: "..." }] }
+ *
+ * The stable marker lives in the command string itself for idempotency
+ * detection (see CLAUDE_HOOK_MARKER / "session-start-drift-check").
+ *
+ * @returns {object} Claude hook entry in the required shape.
+ */
+function makeClaudeHookEntry() {
+  return {
+    matcher: ".*",
+    hooks: [
+      {
+        type: "command",
+        command: `node ${DRIFT_CHECK_SCRIPT}`,
+      },
+    ],
+  };
+}
+
+/**
+ * Read and parse settings.json. Returns empty object on missing/error.
+ */
+function readSettings(settingsPath) {
+  if (!existsSync(settingsPath)) return {};
+  try {
+    return JSON.parse(readFileSync(settingsPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write settings.json (pretty-printed JSON, creates parent dir).
+ */
+function writeSettings(settingsPath, settings) {
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+
+/**
+ * Register the drift-check hook in Claude's (or Cursor's) settings.json.
+ * Idempotent: skips if marker already present.
+ *
+ * @param {string} settingsPath - Absolute path to settings.json
+ * @returns {"registered"|"already_registered"} result
+ */
+function registerClaudeHook(settingsPath) {
+  const settings = readSettings(settingsPath);
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionStart)) settings.hooks.SessionStart = [];
+
+  // Check if already registered (idempotency).
+  // Marker is the path substring "session-start-drift-check" in the nested command.
+  const entryMatchesDriftCheck = (e) =>
+    e &&
+    (
+      // New schema: { matcher, hooks: [{ type, command }] }
+      (Array.isArray(e.hooks) && e.hooks.some((h) => (h.command ?? "").includes("session-start-drift-check"))) ||
+      // Old schema (pre-fix): { _enact_marker, command } — tolerate during transition.
+      e._enact_marker === CLAUDE_HOOK_MARKER ||
+      (e.command ?? "").includes("session-start-drift-check")
+    );
+  const alreadyPresent = settings.hooks.SessionStart.some(entryMatchesDriftCheck);
+  if (alreadyPresent) return "already_registered";
+
+  settings.hooks.SessionStart.push(makeClaudeHookEntry());
+  writeSettings(settingsPath, settings);
+  return "registered";
+}
+
+/**
+ * Remove the drift-check hook from Claude's (or Cursor's) settings.json.
+ * Idempotent: safe if entry not present.
+ *
+ * @param {string} settingsPath
+ * @returns {"removed"|"not_found"} result
+ */
+function removeClaudeHook(settingsPath) {
+  if (!existsSync(settingsPath)) return "not_found";
+  const settings = readSettings(settingsPath);
+  if (!settings.hooks?.SessionStart) return "not_found";
+
+  const before = settings.hooks.SessionStart.length;
+  settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
+    (e) => !(
+      e &&
+      (
+        // New schema: { matcher, hooks: [{ type, command }] }
+        (Array.isArray(e.hooks) && e.hooks.some((h) => (h.command ?? "").includes("session-start-drift-check"))) ||
+        // Old schema (pre-fix): { _enact_marker, command }
+        e._enact_marker === CLAUDE_HOOK_MARKER ||
+        (e.command ?? "").includes("session-start-drift-check")
+      )
+    ),
+  );
+  if (settings.hooks.SessionStart.length === before) return "not_found";
+
+  writeSettings(settingsPath, settings);
+  return "removed";
+}
+
+// ---------------------------------------------------------------------------
+// Codex / Enact config.toml helpers
+//
+// Assumption: the codex-fork and enact-agent config.toml supports a
+// `[[hooks.session_start]]` array of tables, each with a `command` field.
+// This mirrors common codex-rs config patterns. If the exact schema differs,
+// the entry is still safely parseable as TOML and clearly marked for removal.
+// ---------------------------------------------------------------------------
+
+const TOML_HOOK_BLOCK = (scriptPath) => `
+# [enact-extensions:session-start-drift-check] BEGIN — do not edit this line
+[[hooks.session_start]]
+command = "node ${scriptPath}"
+# [enact-extensions:session-start-drift-check] END
+`;
+
+const TOML_BEGIN_MARKER = `# [${TOML_HOOK_MARKER}] BEGIN`;
+const TOML_END_MARKER = `# [${TOML_HOOK_MARKER}] END`;
+
+/**
+ * Read config.toml content. Returns empty string on missing.
+ */
+function readToml(configPath) {
+  if (!existsSync(configPath)) return "";
+  try {
+    return readFileSync(configPath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Write config.toml (creates parent dir).
+ */
+function writeToml(configPath, content) {
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, content, "utf8");
+}
+
+/**
+ * Register the drift-check hook in a codex/enact config.toml.
+ * Idempotent: checks for the BEGIN marker before appending.
+ *
+ * @param {string} configPath
+ * @returns {"registered"|"already_registered"} result
+ */
+function registerTomlHook(configPath) {
+  const existing = readToml(configPath);
+  if (existing.includes(TOML_BEGIN_MARKER)) return "already_registered";
+
+  const block = TOML_HOOK_BLOCK(DRIFT_CHECK_SCRIPT);
+  writeToml(configPath, existing + block);
+  return "registered";
+}
+
+/**
+ * Remove the drift-check hook block from config.toml.
+ * Removes the content between BEGIN and END markers (inclusive).
+ *
+ * @param {string} configPath
+ * @returns {"removed"|"not_found"} result
+ */
+function removeTomlHook(configPath) {
+  const existing = readToml(configPath);
+  if (!existing.includes(TOML_BEGIN_MARKER)) return "not_found";
+
+  // Remove the marked block (BEGIN line through END line, inclusive).
+  const beginIdx = existing.indexOf(TOML_BEGIN_MARKER);
+  const endIdx = existing.indexOf(TOML_END_MARKER);
+  if (beginIdx === -1 || endIdx === -1) return "not_found";
+
+  // Include the newline before BEGIN and after END.
+  const beforeBegin = existing.slice(0, beginIdx).replace(/\n$/, "");
+  const afterEnd = existing.slice(endIdx + TOML_END_MARKER.length).replace(/^\n/, "");
+  const newContent = beforeBegin + (afterEnd ? "\n" + afterEnd : "");
+
+  writeToml(configPath, newContent);
+  return "removed";
+}
+
+// ---------------------------------------------------------------------------
+// Public API: registerHook / removeHook for each surface
+// ---------------------------------------------------------------------------
+
+/**
+ * Register the session-start drift-check hook for a given surface.
+ *
+ * @param {string} surface — "claude" | "codex" | "cursor" | "enact"
+ * @param {object} [opts]
+ * @param {string} [opts.claudeHome]
+ * @param {string} [opts.codexHome]
+ * @param {string} [opts.cursorHome]
+ * @param {string} [opts.enactHome]
+ * @param {boolean} [opts.local] — if true, use project-local home under cwd
+ * @param {string} [opts.cwd] — cwd for --local resolution
+ * @returns {{ surface: string, result: "registered"|"already_registered"|"skipped", note?: string }}
+ */
+export function registerHook(surface, opts = {}) {
+  try {
+    switch (surface) {
+      case "claude": {
+        const home = opts.claudeHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".claude") : defaultHome("claude"));
+        const settingsPath = join(home, "settings.json");
+        const result = registerClaudeHook(settingsPath);
+        return { surface, result, location: settingsPath };
+      }
+
+      case "cursor": {
+        // Cursor mirrors Claude's settings.json approach.
+        // NOTE: Cursor's actual hook schema may differ — this uses the same
+        // SessionStart format as Claude. Reverse with --remove if unwanted.
+        const home = opts.cursorHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".cursor") : defaultHome("cursor"));
+        const settingsPath = join(home, "settings.json");
+        const result = registerClaudeHook(settingsPath);
+        return {
+          surface,
+          result,
+          location: settingsPath,
+          note: "Assumption: Cursor uses settings.json SessionStart hooks (same as Claude Code). Verify if Cursor's actual hook schema differs.",
+        };
+      }
+
+      case "codex": {
+        const home = opts.codexHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".codex") : defaultHome("codex"));
+        const configPath = join(home, "config.toml");
+        const result = registerTomlHook(configPath);
+        return {
+          surface,
+          result,
+          location: configPath,
+          note: "Assumption: codex config.toml supports [[hooks.session_start]] with a command field.",
+        };
+      }
+
+      case "enact": {
+        const home = opts.enactHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".enact", "agent") : defaultHome("enact"));
+        const configPath = join(home, "config.toml");
+        const result = registerTomlHook(configPath);
+        return {
+          surface,
+          result,
+          location: configPath,
+          note: "Assumption: enact-agent config.toml supports [[hooks.session_start]] with a command field.",
+        };
+      }
+
+      default:
+        return { surface, result: "skipped", note: `Unknown surface: ${surface}` };
+    }
+  } catch (err) {
+    // Never crash — return skipped with the error note.
+    return {
+      surface,
+      result: "skipped",
+      note: `Error: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
+/**
+ * Remove the session-start drift-check hook for a given surface.
+ *
+ * @param {string} surface
+ * @param {object} [opts] — same as registerHook
+ * @returns {{ surface: string, result: "removed"|"not_found"|"skipped", note?: string }}
+ */
+export function removeHook(surface, opts = {}) {
+  try {
+    switch (surface) {
+      case "claude": {
+        const home = opts.claudeHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".claude") : defaultHome("claude"));
+        const settingsPath = join(home, "settings.json");
+        const result = removeClaudeHook(settingsPath);
+        return { surface, result, location: settingsPath };
+      }
+
+      case "cursor": {
+        const home = opts.cursorHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".cursor") : defaultHome("cursor"));
+        const settingsPath = join(home, "settings.json");
+        const result = removeClaudeHook(settingsPath);
+        return { surface, result, location: settingsPath };
+      }
+
+      case "codex": {
+        const home = opts.codexHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".codex") : defaultHome("codex"));
+        const configPath = join(home, "config.toml");
+        const result = removeTomlHook(configPath);
+        return { surface, result, location: configPath };
+      }
+
+      case "enact": {
+        const home = opts.enactHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".enact", "agent") : defaultHome("enact"));
+        const configPath = join(home, "config.toml");
+        const result = removeTomlHook(configPath);
+        return { surface, result, location: configPath };
+      }
+
+      default:
+        return { surface, result: "skipped", note: `Unknown surface: ${surface}` };
+    }
+  } catch (err) {
+    return {
+      surface,
+      result: "skipped",
+      note: `Error: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
+// The 4 supported surfaces.
+export const SUPPORTED_SURFACES = ["claude", "codex", "cursor", "enact"];