Transformer Math

async function checkPermission(
  tool: Tool,
  input: ToolInput,
  hooks: Hooks,
  rules: Rules,
  mode: PermissionMode
): Promise<PermissionResult> {
  // Layer 1: Pre-tool hooks (highest priority)
  for (const hook of hooks.preToolUse) {
    const result = await runShell(hook.command, { stdin: JSON.stringify({ tool, input }) });
    if (result.exitCode === 0) {
      // exit 0 = hook passed (continue to next layer)
      // Input modification via hookSpecificOutput.updatedInput in JSON stdout
      const json = result.stdout ? JSON.parse(result.stdout) : {};
      if (json.hookSpecificOutput?.updatedInput) input = json.hookSpecificOutput.updatedInput;
      // Note: exit 0 does NOT unconditionally allow — subsequent layers still run
    } else if (result.exitCode === 2) {
      return { decision: "deny", reason: result.stderr }; // explicit deny
    }
    // other nonzero = non-blocking error (tool continues)
  }

  // Layer 2: Deny rules (absolute blocks)
  for (const rule of rules.alwaysDeny) {
    if (matches(rule, tool, input)) return { decision: "deny" };
  }

  // Layer 3: Allow rules (auto-approve patterns)
  for (const rule of rules.alwaysAllow) {
    if (matches(rule, tool, input)) return { decision: "allow" };
  }

  // Layer 4: Permission mode
  if (mode === "bypassPermissions") return { decision: "allow" };
  if (mode === "plan" && !tool.isReadOnly()) return { decision: "deny" };
  if (mode === "acceptEdits" && ["Edit", "Write"].includes(tool.name)) return { decision: "allow" };

  // Layer 5: Ask user (interactive TUI dialog)
  return promptUser(tool, input);
}

async function runHook(
  hookCommand: string,
  toolName: string,
  toolInput: ToolInput
): Promise<HookResult> {
  // Execute a shell hook and interpret the result
  const stdinData = JSON.stringify({ tool: toolName, input: toolInput });

  const result = await runProcess(hookCommand, {
    input: stdinData,
    captureOutput: true,
    timeout: 600_000,  // 10min default — configurable via hook.timeout field
  });

  if (result.exitCode === 0) {
    // exit 0: parse stdout JSON for structured response
    // To modify input, return hookSpecificOutput.updatedInput in the JSON
    const json = result.stdout ? JSON.parse(result.stdout) : {};
    const updatedInput = json.hookSpecificOutput?.updatedInput ?? toolInput;
    return { decision: "allow", input: updatedInput };
  } else if (result.exitCode === 2) {
    // exit 2: blocking error — tool call is denied, stderr shown to user
    return { decision: "deny", reason: result.stderr };
  } else {
    // other nonzero: non-blocking error — logged, tool proceeds
    console.warn(`Hook failed: ${result.stderr}`);
    return { decision: "continue", input: toolInput };
  }
}

function matches(rulePattern: string, toolName: string, toolInput: ToolInput): boolean {
  // Match tool calls against rule patterns
  //
  // Patterns:
  //   "Read"              → matches all Read tool calls
  //   "Bash(npm test)"    → matches Bash with 'npm test' in command
  //   "Edit(src/**)"      → matches Edit with file_path matching glob

  // Parse pattern: "ToolName(argument_pattern)"
  const match = rulePattern.match(/^(\w+)(?:\((.+)\))?$/);
  if (!match) return false;

  const [, ruleTool, ruleArg] = match;

  if (ruleTool !== toolName) return false;
  if (ruleArg === undefined) return true;  // matches all calls to this tool

  // Check if argument pattern appears in any input field
  return Object.values(toolInput).some(v => String(v).includes(ruleArg));
}