@within-7/minto 0.3.9 → 0.4.0

package/dist/utils/hookManager.js

@@ -1,27 +1,80 @@
-import { HookEvent } from "../types/hooks.js";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { HookEvent, HooksConfigSchema } from "../types/hooks.js";
+import { emitReminderEvent } from "../services/systemReminder.js";
 import {
   executeHooksForEvent,
   processHookDecisions,
   createPreToolUseInput,
   createPostToolUseInput,
+  createPostToolUseFailureInput,
+  createPermissionRequestInput,
   createUserPromptSubmitInput,
   createSessionStartInput,
-  createSessionEndInput
+  createSessionEndInput,
+  createStopInput,
+  createSubagentStartInput,
+  createSubagentStopInput,
+  createNotificationInput,
+  createPreCompactInput,
+  createPostCompactInput,
+  createConfigChangeInput,
+  createTaskCompletedInput,
+  createTeammateIdleInput,
+  resetOnceHooks
 } from "../services/hookExecutor.js";
+import { safeParseJSON } from "./json.js";
+import { getCwd } from "./state.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);
 };
+function matchHook(hook, toolName, toolInput) {
+  if (hook.matcher) {
+    if (hook.matcher !== "*" && hook.matcher !== "") {
+      try {
+        const regex = new RegExp(hook.matcher);
+        if (!regex.test(toolName)) return false;
+      } catch {
+        if (hook.matcher !== toolName) return false;
+      }
+    }
+  }
+  const hookConfig = hook.config;
+  if (hookConfig.toolInput && toolInput) {
+    for (const [field, pattern] of Object.entries(
+      hookConfig.toolInput
+    )) {
+      const fieldValue = String(toolInput[field] ?? "");
+      try {
+        const regex = new RegExp(pattern);
+        if (!regex.test(fieldValue)) return false;
+      } catch {
+        if (fieldValue !== pattern) return false;
+      }
+    }
+  }
+  return true;
+}
+const ALLOW_RESULT = {
+  shouldContinue: true,
+  shouldAskUser: false
+};
 class HookManager {
   plugins = [];
+  settingsHooks = [];
+  managedHooks = [];
   sessionId;
   transcriptPath;
   enabled = true;
+  disableAllHooks = false;
   constructor(sessionId, transcriptPath) {
     this.sessionId = sessionId;
     this.transcriptPath = transcriptPath;
+    resetOnceHooks();
   }
   /**
    * Register plugins with hooks
@@ -33,6 +86,94 @@ class HookManager {
       `HookManager: Registered ${plugins.length} plugin(s) with ${totalHooks} hook(s)`
     );
   }
+  /**
+   * Load hooks from settings.json files
+   * Priority (high to low): managed > .minto/settings.json > .claude/settings.json >
+   *   .minto/settings.local.json > ~/.minto/settings.json > ~/.claude/settings.json
+   */
+  loadSettingsHooks() {
+    const cwd = getCwd();
+    const home = homedir();
+    const settingsPaths = [
+      join(home, ".claude", "settings.json"),
+      join(home, ".minto", "settings.json"),
+      join(cwd, ".minto", "settings.local.json"),
+      join(cwd, ".claude", "settings.json"),
+      join(cwd, ".minto", "settings.json")
+    ];
+    const allHooks = [];
+    for (const settingsPath of settingsPaths) {
+      try {
+        if (!existsSync(settingsPath)) continue;
+        const content = readFileSync(settingsPath, "utf-8");
+        const settings = safeParseJSON(content);
+        if (!settings || typeof settings !== "object") continue;
+        const hooksConfig = settings.hooks;
+        if (!hooksConfig || typeof hooksConfig !== "object") continue;
+        const parsed = HooksConfigSchema.safeParse({ hooks: hooksConfig });
+        if (!parsed.success) {
+          logDebug(`Invalid hooks in ${settingsPath}: ${parsed.error.message}`);
+          continue;
+        }
+        const hooks = parsed.data.hooks;
+        if (!hooks) continue;
+        for (const [eventName, matchers] of Object.entries(hooks)) {
+          const event = eventName;
+          for (const matcher of matchers) {
+            for (let i = 0; i < matcher.hooks.length; i++) {
+              const hookDef = matcher.hooks[i];
+              allHooks.push({
+                name: `settings:${eventName}:${i}`,
+                filePath: settingsPath,
+                config: {
+                  event,
+                  matcher: matcher.matcher,
+                  type: hookDef.type,
+                  command: hookDef.command,
+                  timeout: hookDef.timeout,
+                  once: hookDef.once,
+                  async: hookDef.async
+                },
+                pluginName: "settings",
+                event,
+                matcher: matcher.matcher
+              });
+            }
+          }
+        }
+      } catch (err) {
+        logDebug(`Error loading hooks from ${settingsPath}: ${err}`);
+      }
+    }
+    this.settingsHooks = allHooks;
+    try {
+      const localSettings = join(cwd, ".minto", "settings.json");
+      const globalSettings = join(home, ".minto", "settings.json");
+      for (const p of [localSettings, globalSettings]) {
+        if (existsSync(p)) {
+          const content = safeParseJSON(readFileSync(p, "utf-8"));
+          if (content && content.disableAllHooks) {
+            this.disableAllHooks = true;
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+    logInfo(`HookManager: Loaded ${allHooks.length} hook(s) from settings`);
+  }
+  /**
+   * Dynamically add temporary hooks (e.g., skill-level hooks)
+   * Returns a cleanup function to remove them
+   */
+  addHooks(hooks) {
+    this.settingsHooks.push(...hooks);
+    logDebug(`HookManager: Added ${hooks.length} temporary hook(s)`);
+    return () => {
+      this.settingsHooks = this.settingsHooks.filter((h) => !hooks.includes(h));
+      logDebug(`HookManager: Removed ${hooks.length} temporary hook(s)`);
+    };
+  }
   /**
    * Enable or disable hook execution
    */
@@ -41,80 +182,117 @@ class HookManager {
     logDebug(`HookManager: ${enabled ? "Enabled" : "Disabled"}`);
   }
   /**
-   * Execute PreToolUse hooks
+   * Get all hooks (plugins + settings), respecting disableAllHooks
    */
-  async executePreToolUse(toolName, toolInput) {
-    if (!this.enabled) {
-      return { shouldContinue: true, shouldAskUser: false };
+  getAllHooks() {
+    const managed = this.managedHooks;
+    if (this.disableAllHooks) {
+      return managed;
     }
-    const allHooks = this.plugins.flatMap((p) => p.hooks);
-    const matchingHooks = allHooks.filter((hook) => {
-      if (hook.event !== HookEvent.PreToolUse) return false;
-      if (!hook.matcher) return true;
-      if (hook.matcher === "*" || hook.matcher === "") return true;
-      try {
-        const regex = new RegExp(hook.matcher);
-        return regex.test(toolName);
-      } catch {
-        return hook.matcher === toolName;
-      }
+    const pluginHooks = this.plugins.flatMap((p) => p.hooks);
+    return [...pluginHooks, ...this.settingsHooks, ...managed];
+  }
+  /**
+   * Get matching hooks for a tool-based event
+   */
+  getMatchingToolHooks(event, toolName, toolInput) {
+    const allHooks = this.getAllHooks();
+    const matching = allHooks.filter((hook) => {
+      if (hook.event !== event) return false;
+      return matchHook(hook, toolName, toolInput);
     });
-    if (matchingHooks.length === 0) {
-      return { shouldContinue: true, shouldAskUser: false };
-    }
-    logDebug(
-      `PreToolUse: ${matchingHooks.length} hook(s) matched for tool: ${toolName}`
-    );
-    const input = createPreToolUseInput(
-      this.sessionId,
-      this.transcriptPath,
-      toolName,
-      toolInput
-    );
+    return { hooks: matching, plugins: this.plugins };
+  }
+  /**
+   * Get matching hooks for a non-tool event
+   */
+  getMatchingEventHooks(event) {
+    return this.getAllHooks().filter((hook) => hook.event === event);
+  }
+  /**
+   * Find plugin root for a hook
+   */
+  getPluginRoot(hook) {
+    const plugin = this.plugins.find((p) => p.manifest.name === hook.pluginName);
+    return plugin?.location || getCwd();
+  }
+  /**
+   * Execute hooks for a tool-based event (PreToolUse, PostToolUse, etc.)
+   */
+  async executeToolEvent(event, toolName, input, toolInput) {
+    if (!this.enabled) return ALLOW_RESULT;
+    const { hooks } = this.getMatchingToolHooks(event, toolName, toolInput);
+    if (hooks.length === 0) return ALLOW_RESULT;
+    logDebug(`${event}: ${hooks.length} hook(s) matched for tool: ${toolName}`);
     const results = [];
-    for (const hook of matchingHooks) {
-      const plugin = this.plugins.find((p) => p.manifest.name === hook.pluginName);
-      if (!plugin) continue;
+    for (const hook of hooks) {
       const options = {
         sessionId: this.sessionId,
         transcriptPath: this.transcriptPath,
-        pluginRoot: plugin.location
+        pluginRoot: this.getPluginRoot(hook)
       };
-      const result = await executeHooksForEvent(
-        HookEvent.PreToolUse,
-        [hook],
-        input,
-        options
-      );
+      const result = await executeHooksForEvent(event, [hook], input, options);
       results.push(...result);
     }
     return processHookDecisions(results);
   }
   /**
-   * Execute PostToolUse hooks
+   * Execute hooks for a non-tool event (fire-and-forget)
    */
-  async executePostToolUse(toolName, toolInput, toolOutput) {
-    if (!this.enabled) {
-      return;
-    }
-    const allHooks = this.plugins.flatMap((p) => p.hooks);
-    const matchingHooks = allHooks.filter((hook) => {
-      if (hook.event !== HookEvent.PostToolUse) return false;
-      if (!hook.matcher) return true;
-      if (hook.matcher === "*" || hook.matcher === "") return true;
-      try {
-        const regex = new RegExp(hook.matcher);
-        return regex.test(toolName);
-      } catch {
-        return hook.matcher === toolName;
-      }
-    });
-    if (matchingHooks.length === 0) {
-      return;
+  async executeFireAndForget(event, input) {
+    if (!this.enabled) return;
+    const hooks = this.getMatchingEventHooks(event);
+    if (hooks.length === 0) return;
+    logDebug(`${event}: ${hooks.length} hook(s)`);
+    await Promise.allSettled(
+      hooks.map((hook) => {
+        const options = {
+          sessionId: this.sessionId,
+          transcriptPath: this.transcriptPath,
+          pluginRoot: this.getPluginRoot(hook)
+        };
+        return executeHooksForEvent(event, [hook], input, options);
+      })
+    );
+  }
+  /**
+   * Execute hooks for a blockable non-tool event
+   */
+  async executeBlockableEvent(event, input) {
+    if (!this.enabled) return ALLOW_RESULT;
+    const hooks = this.getMatchingEventHooks(event);
+    if (hooks.length === 0) return ALLOW_RESULT;
+    logDebug(`${event}: ${hooks.length} hook(s)`);
+    const results = [];
+    for (const hook of hooks) {
+      const options = {
+        sessionId: this.sessionId,
+        transcriptPath: this.transcriptPath,
+        pluginRoot: this.getPluginRoot(hook)
+      };
+      const result = await executeHooksForEvent(event, [hook], input, options);
+      results.push(...result);
     }
-    logDebug(
-      `PostToolUse: ${matchingHooks.length} hook(s) matched for tool: ${toolName}`
+    return processHookDecisions(results);
+  }
+  // ========================================================================
+  // Public event methods
+  // ========================================================================
+  async executePreToolUse(toolName, toolInput) {
+    const input = createPreToolUseInput(
+      this.sessionId,
+      this.transcriptPath,
+      toolName,
+      toolInput
+    );
+    return this.executeToolEvent(
+      HookEvent.PreToolUse,
+      toolName,
+      input,
+      toolInput
     );
+  }
+  async executePostToolUse(toolName, toolInput, toolOutput) {
     const input = createPostToolUseInput(
       this.sessionId,
       this.transcriptPath,
@@ -122,119 +300,175 @@ class HookManager {
       toolInput,
       toolOutput
     );
-    for (const hook of matchingHooks) {
-      const plugin = this.plugins.find((p) => p.manifest.name === hook.pluginName);
-      if (!plugin) continue;
-      const options = {
-        sessionId: this.sessionId,
-        transcriptPath: this.transcriptPath,
-        pluginRoot: plugin.location
-      };
-      await executeHooksForEvent(HookEvent.PostToolUse, [hook], input, options);
-    }
+    await this.executeFireAndForget(HookEvent.PostToolUse, input);
+  }
+  async executePostToolUseFailure(toolName, toolInput, error, errorType) {
+    const input = createPostToolUseFailureInput(
+      this.sessionId,
+      this.transcriptPath,
+      toolName,
+      toolInput,
+      error,
+      errorType
+    );
+    await this.executeFireAndForget(HookEvent.PostToolUseFailure, input);
+    emitReminderEvent("diagnostics:new", {
+      source: toolName,
+      count: 1
+    });
+  }
+  async executePermissionRequest(toolName, toolInput, permissionType, description) {
+    const input = createPermissionRequestInput(
+      this.sessionId,
+      this.transcriptPath,
+      toolName,
+      toolInput,
+      permissionType,
+      description
+    );
+    return this.executeBlockableEvent(HookEvent.PermissionRequest, input);
   }
-  /**
-   * Execute UserPromptSubmit hooks
-   */
   async executeUserPromptSubmit(userPrompt) {
-    if (!this.enabled) {
-      return { shouldContinue: true, shouldAskUser: false };
+    const input = createUserPromptSubmitInput(
+      this.sessionId,
+      this.transcriptPath,
+      userPrompt
+    );
+    return this.executeBlockableEvent(HookEvent.UserPromptSubmit, input);
+  }
+  async executeSessionStart() {
+    const input = createSessionStartInput(this.sessionId, this.transcriptPath);
+    await this.executeFireAndForget(HookEvent.SessionStart, input);
+  }
+  async executeSessionEnd(reason = "other") {
+    const input = createSessionEndInput(
+      this.sessionId,
+      this.transcriptPath,
+      reason
+    );
+    await this.executeFireAndForget(HookEvent.SessionEnd, input);
+  }
+  async executeStop(lastAssistantMessage) {
+    const input = createStopInput(this.sessionId, this.transcriptPath, true);
+    if (lastAssistantMessage) {
+      ;
+      input.last_assistant_message = lastAssistantMessage;
     }
-    const allHooks = this.plugins.flatMap((p) => p.hooks);
-    const matchingHooks = allHooks.filter(
-      (hook) => hook.event === HookEvent.UserPromptSubmit
+    return this.executeBlockableEvent(HookEvent.Stop, input);
+  }
+  async executeSubagentStart(agentType, agentDescription, runInBackground) {
+    const input = createSubagentStartInput(
+      this.sessionId,
+      this.transcriptPath,
+      agentType,
+      agentDescription,
+      runInBackground
+    );
+    await this.executeFireAndForget(HookEvent.SubagentStart, input);
+  }
+  async executeSubagentStop(agentType, agentId, transcriptPath, lastMessage) {
+    const input = createSubagentStopInput(
+      this.sessionId,
+      this.transcriptPath,
+      agentType,
+      agentId
     );
-    if (matchingHooks.length === 0) {
-      return { shouldContinue: true, shouldAskUser: false };
+    if (transcriptPath) {
+      ;
+      input.agent_transcript_path = transcriptPath;
     }
-    logDebug(`UserPromptSubmit: ${matchingHooks.length} hook(s)`);
-    const input = createUserPromptSubmitInput(
+    if (lastMessage) {
+      ;
+      input.last_message = lastMessage;
+    }
+    return this.executeBlockableEvent(HookEvent.SubagentStop, input);
+  }
+  async executeNotification(message, title, type) {
+    if (!this.enabled) return {};
+    const input = createNotificationInput(
       this.sessionId,
       this.transcriptPath,
-      userPrompt
+      message,
+      title,
+      type
     );
+    const hooks = this.getMatchingEventHooks(HookEvent.Notification);
+    if (hooks.length === 0) return {};
     const results = [];
-    for (const hook of matchingHooks) {
-      const plugin = this.plugins.find((p) => p.manifest.name === hook.pluginName);
-      if (!plugin) continue;
+    for (const hook of hooks) {
       const options = {
         sessionId: this.sessionId,
         transcriptPath: this.transcriptPath,
-        pluginRoot: plugin.location
+        pluginRoot: this.getPluginRoot(hook)
       };
       const result = await executeHooksForEvent(
-        HookEvent.UserPromptSubmit,
+        HookEvent.Notification,
         [hook],
         input,
         options
       );
       results.push(...result);
     }
-    return processHookDecisions(results);
+    const suppress = results.some(
+      (r) => r.success && r.output?.suppressNotification
+    );
+    return { suppressNotification: suppress };
   }
-  /**
-   * Execute SessionStart hooks
-   */
-  async executeSessionStart() {
-    if (!this.enabled) {
-      return;
-    }
-    const allHooks = this.plugins.flatMap((p) => p.hooks);
-    const matchingHooks = allHooks.filter(
-      (hook) => hook.event === HookEvent.SessionStart
+  async executePreCompact(trigger, customInstructions) {
+    const input = createPreCompactInput(
+      this.sessionId,
+      this.transcriptPath,
+      trigger,
+      customInstructions || ""
     );
-    if (matchingHooks.length === 0) {
-      return;
-    }
-    logInfo(`SessionStart: Executing ${matchingHooks.length} hook(s)`);
-    const input = createSessionStartInput(this.sessionId, this.transcriptPath);
-    for (const hook of matchingHooks) {
-      const plugin = this.plugins.find((p) => p.manifest.name === hook.pluginName);
-      if (!plugin) continue;
-      const options = {
-        sessionId: this.sessionId,
-        transcriptPath: this.transcriptPath,
-        pluginRoot: plugin.location
-      };
-      await executeHooksForEvent(HookEvent.SessionStart, [hook], input, options);
-    }
+    await this.executeFireAndForget(HookEvent.PreCompact, input);
   }
-  /**
-   * Execute SessionEnd hooks
-   */
-  async executeSessionEnd(reason = "other") {
-    if (!this.enabled) {
-      return;
-    }
-    const allHooks = this.plugins.flatMap((p) => p.hooks);
-    const matchingHooks = allHooks.filter(
-      (hook) => hook.event === HookEvent.SessionEnd
+  async executePostCompact(trigger, summary, compressionRatio, originalTokens, compressedTokens) {
+    const input = createPostCompactInput(
+      this.sessionId,
+      this.transcriptPath,
+      trigger,
+      summary,
+      compressionRatio,
+      originalTokens,
+      compressedTokens
     );
-    if (matchingHooks.length === 0) {
-      return;
-    }
-    logInfo(`SessionEnd: Executing ${matchingHooks.length} hook(s)`);
-    const input = createSessionEndInput(
+    await this.executeFireAndForget(HookEvent.PostCompact, input);
+  }
+  async executeConfigChange(source, filePath) {
+    const input = createConfigChangeInput(
       this.sessionId,
       this.transcriptPath,
-      reason
+      source,
+      filePath
     );
-    for (const hook of matchingHooks) {
-      const plugin = this.plugins.find((p) => p.manifest.name === hook.pluginName);
-      if (!plugin) continue;
-      const options = {
-        sessionId: this.sessionId,
-        transcriptPath: this.transcriptPath,
-        pluginRoot: plugin.location
-      };
-      await executeHooksForEvent(HookEvent.SessionEnd, [hook], input, options);
-    }
+    return this.executeBlockableEvent(HookEvent.ConfigChange, input);
+  }
+  async executeTaskCompleted(taskId, subject, description) {
+    const input = createTaskCompletedInput(
+      this.sessionId,
+      this.transcriptPath,
+      taskId,
+      subject,
+      description
+    );
+    return this.executeBlockableEvent(HookEvent.TaskCompleted, input);
+  }
+  async executeTeammateIdle(teammateName, teamName) {
+    const input = createTeammateIdleInput(
+      this.sessionId,
+      this.transcriptPath,
+      teammateName,
+      teamName
+    );
+    return this.executeBlockableEvent(HookEvent.TeammateIdle, input);
   }
 }
 let globalHookManager = null;
 function initializeHookManager(sessionId, transcriptPath, plugins) {
   globalHookManager = new HookManager(sessionId, transcriptPath);
   globalHookManager.registerPlugins(plugins);
+  globalHookManager.loadSettingsHooks();
   return globalHookManager;
 }
 function getHookManager() {