@within-7/minto 0.4.2 → 0.4.3

package/dist/services/hookExecutor.js

@@ -1,771 +0,0 @@
-import { spawn } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { EventEmitter } from "events";
-import {
-  HookEvent
-} from "../types/hooks.js";
-import { getCwd } from "../utils/state.js";
-import { logError } from "../utils/log.js";
-import { emitReminderEvent } from "./systemReminder.js";
-const logInfo = (msg) => {
-  if (process.env.DEBUG) console.log(`[INFO] ${msg}`);
-};
-const logDebug = (msg, ...args) => {
-  if (process.env.DEBUG) console.log(`[DEBUG] ${msg}`, ...args);
-};
-const hookStatusEmitter = new EventEmitter();
-const executedOnceHooks = /* @__PURE__ */ new Set();
-function resetOnceHooks() {
-  executedOnceHooks.clear();
-}
-function formatHookStatusMessage(event, toolName, hookName, success, errorMessage) {
-  const eventPart = toolName ? `${event}:${toolName}` : event;
-  const statusPart = success ? "succeeded" : "failed";
-  const detailPart = success ? "Success" : errorMessage || "Error";
-  return `${eventPart} hook ${statusPart}: ${detailPart}`;
-}
-function emitStatusEvent(event, toolName, hookName, success, errorMessage) {
-  hookStatusEmitter.emit("status", {
-    event,
-    toolName,
-    success,
-    message: formatHookStatusMessage(
-      event,
-      toolName,
-      hookName,
-      success,
-      errorMessage
-    ),
-    timestamp: Date.now(),
-    hookName
-  });
-}
-function substituteArguments(command, input) {
-  if (!command.includes("$ARGUMENTS")) {
-    return command;
-  }
-  const inputJson = JSON.stringify(input);
-  const escaped = inputJson.replace(/'/g, "'\\''");
-  return command.replace(/\$ARGUMENTS/g, `'${escaped}'`);
-}
-async function executeHook(hook, input, options) {
-  const hookType = hook.config.type || "command";
-  if (hook.config.once) {
-    const hookKey = `${hook.pluginName}:${hook.name}:${hook.event}`;
-    if (executedOnceHooks.has(hookKey)) {
-      logDebug(`Skipping once-hook (already executed): ${hookKey}`);
-      return { success: true };
-    }
-    executedOnceHooks.add(hookKey);
-  }
-  const toolName = "tool_name" in input ? input.tool_name : void 0;
-  if (hook.config.async) {
-    executeHookAsync(hook, input, options, hookType, toolName).catch((err) => {
-      logDebug(`Async hook ${hook.name} error: ${err}`);
-    });
-    return { success: true };
-  }
-  switch (hookType) {
-    case "command":
-      return executeCommandHook(hook, input, options, toolName);
-    case "prompt":
-      return executePromptHook(hook, input, options, toolName);
-    case "agent":
-      return executeAgentHook(hook, input, options, toolName);
-    default:
-      return {
-        success: false,
-        error: `Unknown hook type: ${hookType}`
-      };
-  }
-}
-async function executeHookAsync(hook, input, options, hookType, toolName) {
-  try {
-    let result;
-    switch (hookType) {
-      case "command":
-        result = await executeCommandHook(hook, input, options, toolName);
-        break;
-      case "prompt":
-        result = await executePromptHook(hook, input, options, toolName);
-        break;
-      case "agent":
-        result = await executeAgentHook(hook, input, options, toolName);
-        break;
-      default:
-        return;
-    }
-    if (result.output?.systemMessage) {
-      hookStatusEmitter.emit("asyncResult", {
-        hookName: hook.name,
-        systemMessage: result.output.systemMessage
-      });
-    }
-  } catch {
-  }
-}
-async function executeCommandHook(hook, input, options, toolName) {
-  if (!hook.config.command) {
-    return { success: false, error: "Command hook missing command field" };
-  }
-  const timeout = (hook.config.timeout ? hook.config.timeout * 1e3 : void 0) || options.timeout || 3e4;
-  try {
-    logDebug(`Executing hook: ${hook.name}`);
-    const command = substituteArguments(hook.config.command, input);
-    logDebug(`Command: ${command}`);
-    const result = await executeBashCommand(command, input, {
-      ...options,
-      timeout,
-      pluginRoot: options.pluginRoot
-    });
-    if (result.timedOut) {
-      const errorMsg = `Hook execution timed out after ${timeout}ms`;
-      logError(`Hook ${hook.name} timed out after ${timeout}ms`);
-      emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
-      return { success: false, timedOut: true, error: errorMsg };
-    }
-    if (result.exitCode === 2) {
-      const reason = result.stderr.trim() || "Blocked by hook";
-      logDebug(`Hook ${hook.name} exit code 2 (block): ${reason}`);
-      emitStatusEvent(hook.event, toolName, hook.name, true);
-      return {
-        success: true,
-        decision: "block",
-        blockedByExitCode2: true,
-        blockReason: reason,
-        output: {
-          decision: "block",
-          reason,
-          systemMessage: reason
-        }
-      };
-    }
-    if (result.exitCode !== 0 && result.exitCode !== null) {
-      const errorMsg = `Command exited with code ${result.exitCode}: ${result.stderr}`;
-      logError(`Hook ${hook.name} failed: ${errorMsg}`);
-      emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
-      return { success: false, error: errorMsg };
-    }
-    const output = parseHookOutput(result.stdout, input.hook_event_name);
-    if (!output) {
-      emitStatusEvent(hook.event, toolName, hook.name, true);
-      return { success: true };
-    }
-    logDebug(`Hook ${hook.name} output:`, output);
-    emitStatusEvent(hook.event, toolName, hook.name, true);
-    const decision = resolveDecision(output);
-    return { success: true, decision, output };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logError(`Hook ${hook.name} execution error: ${errorMsg}`);
-    emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
-    return { success: false, error: errorMsg };
-  }
-}
-async function executePromptHook(hook, input, options, toolName) {
-  if (!hook.config.prompt) {
-    return { success: false, error: "Prompt hook missing prompt field" };
-  }
-  const timeout = (hook.config.timeout ? hook.config.timeout * 1e3 : void 0) || 3e4;
-  try {
-    const inputJson = JSON.stringify(input);
-    const prompt = hook.config.prompt.replace(/\$ARGUMENTS/g, inputJson);
-    logDebug(`Executing prompt hook: ${hook.name}`);
-    const { queryQuick } = await import("./claude.js");
-    const abortController = new AbortController();
-    const timer = setTimeout(() => abortController.abort(), timeout);
-    try {
-      const result = await queryQuick({
-        systemPrompt: [
-          'You are a hook evaluator. Respond ONLY with JSON: { "ok": boolean, "reason": string }.',
-          "ok=true means allow the action, ok=false means block it."
-        ],
-        userPrompt: prompt,
-        signal: abortController.signal
-      });
-      clearTimeout(timer);
-      const text = result.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        const decision = parsed.ok ? "approve" : "block";
-        emitStatusEvent(hook.event, toolName, hook.name, true);
-        return {
-          success: true,
-          decision,
-          output: { decision, reason: parsed.reason }
-        };
-      }
-    } catch {
-      clearTimeout(timer);
-    }
-    logDebug(
-      `Prompt hook ${hook.name}: parse failed, defaulting to ask (fail-safe)`
-    );
-    emitStatusEvent(
-      hook.event,
-      toolName,
-      hook.name,
-      false,
-      "Failed to parse hook response"
-    );
-    return { success: true, decision: "ask" };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logError(`Prompt hook ${hook.name} error: ${errorMsg}`);
-    emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
-    return { success: true, decision: "ask" };
-  }
-}
-async function executeAgentHook(hook, input, options, toolName) {
-  if (!hook.config.prompt) {
-    return { success: false, error: "Agent hook missing prompt field" };
-  }
-  const timeout = (hook.config.timeout ? hook.config.timeout * 1e3 : void 0) || 6e4;
-  try {
-    const inputJson = JSON.stringify(input);
-    const prompt = hook.config.prompt.replace(/\$ARGUMENTS/g, inputJson);
-    logDebug(`Executing agent hook: ${hook.name}`);
-    const { queryQuick } = await import("./claude.js");
-    const abortController = new AbortController();
-    const timer = setTimeout(() => abortController.abort(), timeout);
-    try {
-      const result = await queryQuick({
-        systemPrompt: [
-          "You are a hook agent evaluator. You have read-only access to the codebase.",
-          'Evaluate the request and respond ONLY with JSON: { "ok": boolean, "reason": string }.',
-          "ok=true means allow the action, ok=false means block it."
-        ],
-        userPrompt: prompt,
-        signal: abortController.signal
-      });
-      clearTimeout(timer);
-      const text = result.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
-      if (jsonMatch) {
-        const parsed = JSON.parse(jsonMatch[0]);
-        const decision = parsed.ok ? "approve" : "block";
-        emitStatusEvent(hook.event, toolName, hook.name, true);
-        return {
-          success: true,
-          decision,
-          output: { decision, reason: parsed.reason }
-        };
-      }
-    } catch {
-      clearTimeout(timer);
-    }
-    logDebug(
-      `Agent hook ${hook.name}: parse failed, defaulting to ask (fail-safe)`
-    );
-    emitStatusEvent(
-      hook.event,
-      toolName,
-      hook.name,
-      false,
-      "Failed to parse hook response"
-    );
-    return { success: true, decision: "ask" };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logError(`Agent hook ${hook.name} error: ${errorMsg}`);
-    emitStatusEvent(hook.event, toolName, hook.name, false, errorMsg);
-    return { success: true, decision: "ask" };
-  }
-}
-function resolveDecision(output) {
-  if (output.hookSpecificOutput) {
-    const specific = output.hookSpecificOutput;
-    if (specific.permissionDecision) {
-      const mapping = {
-        allow: "approve",
-        deny: "block",
-        ask: "ask",
-        approve: "approve",
-        block: "block"
-      };
-      return mapping[specific.permissionDecision] ?? output.decision;
-    }
-  }
-  return output.decision;
-}
-let claudeEnvFilePath;
-function loadEnvFile() {
-  const envFile = claudeEnvFilePath || process.env.CLAUDE_ENV_FILE;
-  if (!envFile || !existsSync(envFile)) return {};
-  try {
-    const content = readFileSync(envFile, "utf-8");
-    const vars = {};
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx <= 0) continue;
-      const key = trimmed.slice(0, eqIdx).trim();
-      let value = trimmed.slice(eqIdx + 1).trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        value = value.slice(1, -1);
-      }
-      vars[key] = value;
-    }
-    return vars;
-  } catch {
-    return {};
-  }
-}
-function extractFilePathsFromInput(toolInput) {
-  if (!toolInput) return "";
-  const paths = [];
-  if (typeof toolInput.file_path === "string") paths.push(toolInput.file_path);
-  if (typeof toolInput.path === "string") paths.push(toolInput.path);
-  if (typeof toolInput.notebook_path === "string")
-    paths.push(toolInput.notebook_path);
-  return paths.join(":");
-}
-async function executeBashCommand(command, input, options) {
-  return new Promise((resolve) => {
-    const envFileVars = loadEnvFile();
-    const toolName = "tool_name" in input ? input.tool_name : void 0;
-    const toolInput = "tool_input" in input ? input.tool_input : void 0;
-    const toolInputJson = toolInput ? JSON.stringify(toolInput) : "";
-    const filePaths = extractFilePathsFromInput(toolInput);
-    const shellCommand = toolName === "Bash" && toolInput?.command ? String(toolInput.command) : "";
-    const projectDir = getCwd();
-    const env = {
-      ...process.env,
-      ...envFileVars,
-      // CC-compatible env vars
-      CLAUDE_PLUGIN_ROOT: options.pluginRoot,
-      CLAUDE_SESSION_ID: options.sessionId,
-      CLAUDE_CWD: projectDir,
-      CLAUDE_TRANSCRIPT_PATH: options.transcriptPath || "",
-      CLAUDE_PROJECT_DIR: projectDir,
-      CLAUDE_WORKSPACE_DIR: projectDir,
-      CLAUDE_TOOL_INPUT: toolInputJson,
-      CLAUDE_FILE_PATHS: filePaths,
-      CLAUDE_SHELL_COMMAND: shellCommand,
-      // Minto-prefixed duplicates
-      MINTO_PROJECT_DIR: projectDir,
-      MINTO_WORKSPACE_DIR: projectDir,
-      MINTO_TOOL_INPUT: toolInputJson,
-      MINTO_FILE_PATHS: filePaths,
-      MINTO_SHELL_COMMAND: shellCommand
-    };
-    const child = spawn("bash", ["-c", command], {
-      env,
-      cwd: getCwd()
-    });
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-      setTimeout(() => {
-        if (!child.killed) {
-          child.kill("SIGKILL");
-        }
-      }, 1e3);
-    }, options.timeout);
-    child.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (timedOut) {
-        resolve({ stdout: "", stderr: "", exitCode: null, timedOut: true });
-        return;
-      }
-      resolve({ stdout, stderr, exitCode: code });
-    });
-    child.on("error", (error) => {
-      clearTimeout(timer);
-      resolve({
-        stdout: "",
-        stderr: error.message,
-        exitCode: 1
-      });
-    });
-    try {
-      if (child.stdin) {
-        child.stdin.write(JSON.stringify(input, null, 2));
-        child.stdin.end();
-      }
-    } catch (error) {
-      clearTimeout(timer);
-      child.kill();
-      resolve({
-        stdout: "",
-        stderr: `Failed to write to stdin: ${error instanceof Error ? error.message : String(error)}`,
-        exitCode: 1
-      });
-    }
-  });
-}
-function parseHookOutput(stdout, eventName) {
-  if (!stdout.trim()) {
-    return null;
-  }
-  try {
-    const jsonMatch = stdout.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) {
-      logDebug("No JSON found in hook output");
-      return null;
-    }
-    const raw = JSON.parse(jsonMatch[0]);
-    const output = {};
-    if (raw.continue !== void 0) output.continue = raw.continue;
-    if (raw.stopReason) output.stopReason = raw.stopReason;
-    if (raw.suppressOutput !== void 0)
-      output.suppressOutput = raw.suppressOutput;
-    if (raw.systemMessage) output.systemMessage = raw.systemMessage;
-    if (raw.decision) {
-      if (["approve", "block", "ask"].includes(raw.decision)) {
-        output.decision = raw.decision;
-      }
-    }
-    if (raw.reason) output.reason = raw.reason;
-    const specific = raw.hookSpecificOutput || raw;
-    if (eventName === HookEvent.PreToolUse) {
-      if (specific.permissionDecision || specific.updatedInput || specific.permissionDecisionReason) {
-        output.hookSpecificOutput = {
-          hookEventName: HookEvent.PreToolUse,
-          permissionDecision: specific.permissionDecision,
-          permissionDecisionReason: specific.permissionDecisionReason,
-          updatedInput: specific.updatedInput
-        };
-      }
-    } else if (eventName === HookEvent.PostToolUse || eventName === HookEvent.UserPromptSubmit || eventName === HookEvent.SessionStart) {
-      if (specific.additionalContext) {
-        output.hookSpecificOutput = {
-          hookEventName: eventName,
-          additionalContext: specific.additionalContext
-        };
-      }
-      if (eventName === HookEvent.SessionStart && specific.envFile) {
-        claudeEnvFilePath = specific.envFile;
-        process.env.CLAUDE_ENV_FILE = specific.envFile;
-      }
-    }
-    if (eventName === HookEvent.Notification) {
-      if (raw.suppressNotification !== void 0) {
-        ;
-        output.suppressNotification = raw.suppressNotification;
-      }
-    }
-    return output;
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    logError(`Failed to parse hook output JSON: ${errorMsg}`);
-    logDebug("Raw output:", stdout);
-    return null;
-  }
-}
-async function executeHooksForEvent(event, hooks, input, options) {
-  const matchingHooks = hooks.filter((hook) => hook.event === event);
-  if (matchingHooks.length === 0) {
-    return [];
-  }
-  logInfo(`Executing ${matchingHooks.length} hook(s) for event: ${event}`);
-  const results = await Promise.allSettled(
-    matchingHooks.map((hook) => executeHook(hook, input, options))
-  );
-  return results.map(
-    (r) => r.status === "fulfilled" ? r.value : { success: false, error: String(r.reason) }
-  );
-}
-function processHookDecisions(results) {
-  let additionalContext;
-  let updatedInput;
-  for (const r of results) {
-    if (!r.success || !r.output) continue;
-    const specific = r.output.hookSpecificOutput;
-    if (specific?.additionalContext) {
-      additionalContext = additionalContext ? `${additionalContext}
-${specific.additionalContext}` : specific.additionalContext;
-    }
-    if (specific?.updatedInput) {
-      updatedInput = { ...updatedInput || {}, ...specific.updatedInput };
-    }
-  }
-  const blockedResult = results.find(
-    (r) => r.success && r.decision === "block" || r.blockedByExitCode2
-  );
-  if (blockedResult) {
-    const reason = blockedResult.blockReason || blockedResult.output?.reason || "Blocked by hook";
-    emitReminderEvent("hook:blocking_error", { hookName: "hook", reason });
-    return {
-      shouldContinue: false,
-      shouldAskUser: false,
-      reason
-    };
-  }
-  const askResult = results.find((r) => r.success && r.decision === "ask");
-  if (askResult) {
-    return {
-      shouldContinue: false,
-      shouldAskUser: true,
-      reason: askResult.output?.reason || "Hook requested user approval"
-    };
-  }
-  const failedResult = results.find((r) => !r.success);
-  if (failedResult) {
-    const reason = `Hook execution failed: ${failedResult.error}`;
-    emitReminderEvent("hook:stopped_continuation", { hookName: "hook", reason });
-    return {
-      shouldContinue: false,
-      shouldAskUser: true,
-      reason
-    };
-  }
-  if (additionalContext) {
-    emitReminderEvent("hook:additional_context", {
-      hookName: "hook",
-      content: additionalContext
-    });
-  }
-  return {
-    shouldContinue: true,
-    shouldAskUser: false,
-    updatedInput,
-    additionalContext
-  };
-}
-function createPreToolUseInput(sessionId, transcriptPath, toolName, toolInput) {
-  return {
-    hook_event_name: HookEvent.PreToolUse,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    tool_name: toolName,
-    tool_input: toolInput
-  };
-}
-function createPostToolUseInput(sessionId, transcriptPath, toolName, toolInput, toolOutput) {
-  return {
-    hook_event_name: HookEvent.PostToolUse,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    tool_name: toolName,
-    tool_input: toolInput,
-    tool_output: toolOutput
-  };
-}
-function createUserPromptSubmitInput(sessionId, transcriptPath, userPrompt) {
-  return {
-    hook_event_name: HookEvent.UserPromptSubmit,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    user_prompt: userPrompt
-  };
-}
-function createSessionStartInput(sessionId, transcriptPath) {
-  return {
-    hook_event_name: HookEvent.SessionStart,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    source: "startup",
-    permission_mode: "default"
-  };
-}
-function createSessionEndInput(sessionId, transcriptPath, reason) {
-  return {
-    hook_event_name: HookEvent.SessionEnd,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    reason
-  };
-}
-function createPostToolUseFailureInput(sessionId, transcriptPath, toolName, toolInput, error, errorType) {
-  return {
-    hook_event_name: HookEvent.PostToolUseFailure,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    tool_name: toolName,
-    tool_input: toolInput,
-    error,
-    error_type: errorType
-  };
-}
-function createPermissionRequestInput(sessionId, transcriptPath, toolName, toolInput, permissionType, description) {
-  return {
-    hook_event_name: HookEvent.PermissionRequest,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    tool_name: toolName,
-    tool_input: toolInput,
-    permission_type: permissionType,
-    description
-  };
-}
-function createStopInput(sessionId, transcriptPath, stopHookActive) {
-  return {
-    hook_event_name: HookEvent.Stop,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    stop_hook_active: stopHookActive
-  };
-}
-function createSubagentStartInput(sessionId, transcriptPath, agentType, agentDescription, runInBackground) {
-  return {
-    hook_event_name: HookEvent.SubagentStart,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    agent_type: agentType,
-    agent_description: agentDescription,
-    run_in_background: runInBackground
-  };
-}
-function createSubagentStopInput(sessionId, transcriptPath, agentType, agentId, stopHookActive) {
-  return {
-    hook_event_name: HookEvent.SubagentStop,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    agent_type: agentType,
-    agent_id: agentId,
-    stop_hook_active: stopHookActive ?? false
-  };
-}
-function createNotificationInput(sessionId, transcriptPath, message, title, type) {
-  return {
-    hook_event_name: HookEvent.Notification,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    message,
-    ...title ? { title } : {},
-    ...type ? { notification_type: type } : {}
-  };
-}
-function createPreCompactInput(sessionId, transcriptPath, trigger, customInstructions) {
-  return {
-    hook_event_name: HookEvent.PreCompact,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    trigger,
-    custom_instructions: customInstructions
-  };
-}
-function createPostCompactInput(sessionId, transcriptPath, trigger, summary, compressionRatio, originalTokens, compressedTokens) {
-  return {
-    hook_event_name: HookEvent.PostCompact,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    trigger,
-    summary,
-    compression_ratio: compressionRatio,
-    original_tokens: originalTokens,
-    compressed_tokens: compressedTokens
-  };
-}
-function createConfigChangeInput(sessionId, transcriptPath, source, filePath) {
-  return {
-    hook_event_name: HookEvent.ConfigChange,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    source,
-    file_path: filePath
-  };
-}
-function createTaskCompletedInput(sessionId, transcriptPath, taskId, subject, description) {
-  return {
-    hook_event_name: HookEvent.TaskCompleted,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    task_id: taskId,
-    subject,
-    description
-  };
-}
-function createTeammateIdleInput(sessionId, transcriptPath, teammateName, teamName) {
-  return {
-    hook_event_name: HookEvent.TeammateIdle,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    teammate_name: teammateName,
-    team_name: teamName
-  };
-}
-function createWorktreeCreateInput(sessionId, transcriptPath, worktreePath, agentId, agentType) {
-  return {
-    hook_event_name: HookEvent.WorktreeCreate,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    worktree_path: worktreePath,
-    agent_id: agentId,
-    agent_type: agentType
-  };
-}
-function createWorktreeRemoveInput(sessionId, transcriptPath, worktreePath, agentId, agentType, success) {
-  return {
-    hook_event_name: HookEvent.WorktreeRemove,
-    session_id: sessionId,
-    transcript_path: transcriptPath,
-    cwd: getCwd(),
-    permission_mode: "default",
-    worktree_path: worktreePath,
-    agent_id: agentId,
-    agent_type: agentType,
-    success
-  };
-}
-export {
-  createConfigChangeInput,
-  createNotificationInput,
-  createPermissionRequestInput,
-  createPostCompactInput,
-  createPostToolUseFailureInput,
-  createPostToolUseInput,
-  createPreCompactInput,
-  createPreToolUseInput,
-  createSessionEndInput,
-  createSessionStartInput,
-  createStopInput,
-  createSubagentStartInput,
-  createSubagentStopInput,
-  createTaskCompletedInput,
-  createTeammateIdleInput,
-  createUserPromptSubmitInput,
-  createWorktreeCreateInput,
-  createWorktreeRemoveInput,
-  executeHook,
-  executeHooksForEvent,
-  hookStatusEmitter,
-  processHookDecisions,
-  resetOnceHooks
-};
-//# sourceMappingURL=hookExecutor.js.map