failproofai 0.0.9 → 0.0.10-beta.0

package/src/hooks/handler.ts

@@ -5,8 +5,16 @@
  * ~/.failproofai/policies-config.json, evaluates matching policies, persists
  * activity to disk, and returns the appropriate exit code + stdout response.
  */
-import type { HookEventType, IntegrationType, SessionMetadata, CodexHookEventType } from "./types";
-import { CODEX_EVENT_MAP } from "./types";
+import type {
+  HookEventType,
+  IntegrationType,
+  SessionMetadata,
+  CodexHookEventType,
+  CursorHookEventType,
+  PiHookEventType,
+  GeminiHookEventType,
+} from "./types";
+import { CODEX_EVENT_MAP, CURSOR_EVENT_MAP, PI_EVENT_MAP, GEMINI_EVENT_MAP, GEMINI_TOOL_MAP } from "./types";
 import type { PolicyFunction, PolicyResult } from "./policy-types";
 import { readMergedHooksConfig } from "./hooks-config";
 import { registerBuiltinPolicies } from "./builtin-policies";
@@ -22,18 +30,56 @@ import { hookLogInfo, hookLogWarn } from "./hook-logger";
 
 /**
  * Canonicalize an event name to PascalCase. Codex sends snake_case event names
- * on stdin and as the --hook arg; Claude Code sends PascalCase. The internal
- * registry, builtin policies, and policy.match.events all key on PascalCase.
+ * on stdin and as the --hook arg; Cursor sends camelCase (`preToolUse`,
+ * `beforeSubmitPrompt`); Pi sends underscore_lower_snake_case (`tool_call`,
+ * `session_start`); Claude Code sends PascalCase. Copilot CLI is installed
+ * in "VS Code compatible" PascalCase mode (see integrations.ts), so its events
+ * arrive PascalCase already. Gemini also sends PascalCase but with different
+ * names (`BeforeTool`, `BeforeAgent`, `AfterAgent`); we map via GEMINI_EVENT_MAP.
+ * The internal registry, builtin policies, and policy.match.events all key on
+ * PascalCase.
  */
 function canonicalizeEventType(raw: string, cli: IntegrationType): HookEventType {
   if (cli === "codex") {
     const mapped = CODEX_EVENT_MAP[raw as CodexHookEventType];
     if (mapped) return mapped;
   }
-  // Already PascalCase or unknown — pass through; HOOK_EVENT_TYPES type-checks downstream.
+  if (cli === "cursor") {
+    const mapped = CURSOR_EVENT_MAP[raw as CursorHookEventType];
+    if (mapped) return mapped;
+  }
+  if (cli === "pi") {
+    const mapped = PI_EVENT_MAP[raw as PiHookEventType];
+    if (mapped) return mapped;
+  }
+  if (cli === "gemini") {
+    const mapped = GEMINI_EVENT_MAP[raw as GeminiHookEventType];
+    if (mapped) return mapped;
+  }
+  // claude / copilot / unknown — already PascalCase, pass through.
+  // HOOK_EVENT_TYPES type-checks downstream.
   return raw as HookEventType;
 }
 
+/**
+ * Canonicalize a per-CLI tool name to the Claude PascalCase form that builtin
+ * policies match on (e.g. `Bash`, `Read`, `Write`, `Edit`). Today only Gemini
+ * needs this — its tools are snake_case (`run_shell_command`, `read_file`,
+ * `write_file`, `replace`, …). Other CLIs pass through unchanged: Claude /
+ * Codex / Copilot already use PascalCase, and Cursor / Pi pre-canonicalize
+ * inside their own plugin shims before the payload reaches this binary.
+ *
+ * Unknown tool names (MCP `mcp_*`, third-party extensions, Skills) pass
+ * through unchanged so non-builtin tooling isn't lost.
+ */
+function canonicalizeToolName(raw: string | undefined, cli: IntegrationType): string | undefined {
+  if (!raw) return raw;
+  if (cli === "gemini") {
+    return GEMINI_TOOL_MAP[raw] ?? raw;
+  }
+  return raw;
+}
+
 export async function handleHookEvent(
   eventType: string,
   cli: IntegrationType = "claude",
@@ -79,6 +125,17 @@ export async function handleHookEvent(
   // Canonicalize event name (Codex sends snake_case; internals expect PascalCase)
   const canonicalEventType = canonicalizeEventType(eventType, cli);
 
+  // Canonicalize tool name in place so both the policy-registry tool-name
+  // filter and policy bodies (`ctx.toolName === "Bash"`) see the canonical
+  // form. Today only Gemini's snake_case names need translation; other CLIs
+  // are no-ops here. Mutating `parsed.tool_name` keeps the activity store +
+  // telemetry tagging consistent (they read from `parsed.tool_name`).
+  const rawToolName = parsed.tool_name as string | undefined;
+  const canonicalToolName = canonicalizeToolName(rawToolName, cli);
+  if (canonicalToolName !== rawToolName) {
+    parsed.tool_name = canonicalToolName;
+  }
+
   // Extract session metadata from payload
   const sessionId = parsed.session_id as string | undefined;
   const session: SessionMetadata = {
@@ -87,6 +144,11 @@ export async function handleHookEvent(
     cwd: parsed.cwd as string | undefined,
     permissionMode: resolvePermissionMode(cli, parsed, sessionId),
     hookEventName: parsed.hook_event_name as string | undefined,
+    // Preserve the raw CLI-side event name (eventType arg) before
+    // canonicalization. Response shapes that round-trip the agent-emitted
+    // event name (e.g. Gemini's `hookSpecificOutput.hookEventName`) prefer
+    // this over the canonicalized form when stdin omits hook_event_name.
+    rawHookEventName: eventType,
     cli,
   };
 

package/src/hooks/install-prompt.ts

@@ -30,8 +30,13 @@ export interface PromptOptions {
   includeBeta?: boolean;
 }
 
+/** Whether the prompt is being shown for an install or an uninstall flow.
+ *  Drives heading + hint text so `policies --uninstall` no longer says
+ *  "Install Hooks". */
+export type CliPromptAction = "install" | "uninstall";
+
 /**
- * Resolve which agent CLIs to install hooks for.
+ * Resolve which agent CLIs to install/uninstall hooks for.
  *
  * Rules:
  *   • If `explicit` is provided (from `--cli`), use it as-is.
@@ -42,14 +47,26 @@ export interface PromptOptions {
  *
  * Returns the selected IntegrationType[] (always non-empty).
  */
-export async function resolveTargetClis(explicit?: IntegrationType[]): Promise<IntegrationType[]> {
+export async function resolveTargetClis(
+  explicit?: IntegrationType[],
+  action: CliPromptAction = "install",
+): Promise<IntegrationType[]> {
   if (explicit && explicit.length > 0) return [...new Set(explicit)];
 
   const detected = detectInstalledClis();
 
   if (detected.length === 0) {
+    if (action === "uninstall") {
+      // Uninstall flow: no agent CLIs detected — nothing to remove from. Default to
+      // claude so removeHooks operates over Claude's scopes (no-op if no settings file).
+      console.log(
+        "\x1B[33mWarning: no agent CLI binary found in PATH (claude, codex, copilot, cursor-agent, opencode, pi, gemini). " +
+          "Defaulting to Claude Code; nothing will be removed if no settings file exists.\x1B[0m",
+      );
+      return ["claude"];
+    }
     console.log(
-      "\x1B[33mWarning: no agent CLI binary found in PATH (claude, codex). " +
+      "\x1B[33mWarning: no agent CLI binary found in PATH (claude, codex, copilot, cursor-agent, opencode, pi, gemini). " +
         "Defaulting to Claude Code; hooks will activate when an agent is installed.\x1B[0m",
     );
     return ["claude"];
@@ -57,26 +74,29 @@ export async function resolveTargetClis(explicit?: IntegrationType[]): Promise<I
 
   if (detected.length === 1) {
     const integration = getIntegration(detected[0]);
-    console.log(`Detected ${integration.displayName}; installing hooks for it.`);
+    const verb = action === "uninstall" ? "removing hooks from" : "installing hooks for";
+    console.log(`Detected ${integration.displayName}; ${verb} it.`);
     return detected;
   }
 
   // Multiple detected. Prompt or default.
-  if (!process.stdin.isTTY) return detected; // non-interactive: install for all detected
+  if (!process.stdin.isTTY) return detected; // non-interactive: install/remove for all detected
 
-  return promptCliTargetSelection(detected);
+  return promptCliTargetSelection(detected, action);
 }
 
 /**
- * Interactive arrow-key single-select for "install for which CLI?" when
+ * Interactive arrow-key single-select for "install/remove for which CLI?" when
  * multiple agent CLIs are detected. Visual style mirrors promptPolicySelection.
  */
 async function promptCliTargetSelection(
   detected: IntegrationType[],
+  action: CliPromptAction = "install",
 ): Promise<IntegrationType[]> {
   const labels = detected.map((id) => getIntegration(id).displayName).join(" + ");
+  const allLabel = detected.length > 2 ? "All" : "Both";
   const options: Array<{ label: string; description: string; value: IntegrationType[] }> = [
-    { label: "Both", description: labels, value: detected },
+    { label: allLabel, description: labels, value: detected },
     ...detected.map((id) => ({
       label: `${getIntegration(id).displayName} only`,
       description: "",
@@ -122,14 +142,17 @@ async function promptCliTargetSelection(
     return result;
   }
 
+  const heading = action === "uninstall" ? "Remove Hooks" : "Install Hooks";
+  const verb = action === "uninstall" ? "remove from" : "install";
+
   function render(): void {
     const cols = process.stdout.columns || 120;
     hideCursor();
 
     const lines: string[] = [];
-    lines.push("  Failproof AI — Install Hooks");
+    lines.push(`  Failproof AI — ${heading}`);
     lines.push("");
-    lines.push(`  \x1B[2mDetected ${labels}. Choose where to install:\x1B[0m`);
+    lines.push(`  \x1B[2mDetected ${labels}. Choose where to ${verb}:\x1B[0m`);
     lines.push("");
 
     for (let i = 0; i < options.length; i++) {