@wingman-ai/gateway 0.1.0

package/dist/agent/config/toolRegistry.js

@@ -0,0 +1,71 @@
+import { createInternetSearchTool } from "../tools/internet_search.js";
+import { webCrawler } from "../tools/web_crawler.js";
+import { createCommandExecuteTool } from "../tools/command_execute.js";
+import { createThinkingTool } from "../tools/think.js";
+import { createCodeSearchTool } from "../tools/code_search.js";
+import { createGitStatusTool } from "../tools/git_status.js";
+import { createLogger } from "../../logger.js";
+import { MCPClientManager } from "./mcpClientManager.js";
+const logger = createLogger();
+function createTool(name, options = {}) {
+    const { workspace = process.cwd(), blockedCommands, allowScriptExecution = true, timeout = 300000, searchConfig = {
+        provider: "duckduckgo",
+        maxResults: 5
+    } } = options;
+    logger.debug(`Creating tool: ${name}`, {
+        workspace,
+        blockedCommands,
+        allowScriptExecution,
+        timeout,
+        searchConfig
+    });
+    switch(name){
+        case "internet_search":
+            return createInternetSearchTool(searchConfig);
+        case "web_crawler":
+            return webCrawler;
+        case "command_execute":
+            return createCommandExecuteTool(workspace, process.env, blockedCommands, allowScriptExecution, timeout);
+        case "think":
+            return createThinkingTool();
+        case "code_search":
+            return createCodeSearchTool(workspace);
+        case "git_status":
+            return createGitStatusTool(workspace);
+        default:
+            logger.warn(`Unknown tool name: ${name}`);
+            return null;
+    }
+}
+async function createTools(toolNames, options = {}) {
+    const tools = [];
+    for (const name of toolNames){
+        const tool = createTool(name, options);
+        if (tool) tools.push(tool);
+        else logger.warn(`Skipping unknown tool: ${name}`);
+    }
+    if (options.mcpConfigs && options.mcpConfigs.length > 0) try {
+        const mcpManager = new MCPClientManager(options.mcpConfigs, logger);
+        await mcpManager.initialize();
+        const mcpTools = await mcpManager.getTools();
+        if (mcpTools.length > 0) {
+            tools.push(...mcpTools);
+            logger.info(`Added ${mcpTools.length} MCP tool(s)`);
+        }
+    } catch (error) {
+        logger.error(`Failed to load MCP tools: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    logger.info(`Created ${tools.length} total tools: ${toolNames.join(", ")}${options.mcpConfigs?.length ? " + MCP tools" : ""}`);
+    return tools;
+}
+function getAvailableTools() {
+    return [
+        "internet_search",
+        "web_crawler",
+        "command_execute",
+        "think",
+        "code_search",
+        "git_status"
+    ];
+}
+export { createTool, createTools, getAvailableTools };

package/dist/agent/middleware/additional-messages.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    additionalMessageMiddleware: ()=>additionalMessageMiddleware
+});
+const external_langchain_namespaceObject = require("langchain");
+const external_utils_cjs_namespaceObject = require("../utils.cjs");
+const additionalMessageMiddleware = (context = {})=>({
+        name: "additional-message-middleware",
+        [external_langchain_namespaceObject.MIDDLEWARE_BRAND]: true,
+        beforeAgent: async (input)=>{
+            const alreadyInjected = input.messages.some((message)=>message?.additional_kwargs?.source === "additional-message-middleware");
+            if (alreadyInjected) return input;
+            const lines = [
+                (0, external_utils_cjs_namespaceObject.getMachineDetails)(),
+                `** Current Date Time (UTC): ${new Date().toISOString()} **`
+            ];
+            if (context.workdir) lines.push(`** Working directory for outputs: ${context.workdir} **`);
+            else if (context.defaultOutputDir) lines.push(`** No session working directory set. Default output directory: ${context.defaultOutputDir} **`);
+            lines.push("** Long-term memory **\n- Use /memories/ for durable notes across threads.\n- Store stable preferences, project context, decisions, and research notes.\n- Avoid transient logs; keep entries concise and organized.\n- Suggested paths: /memories/preferences.md, /memories/projects/<name>/context.md, /memories/projects/<name>/decisions.md");
+            input.messages.unshift(new external_langchain_namespaceObject.HumanMessage({
+                content: lines.join("\n\n"),
+                additional_kwargs: {
+                    ui_hidden: true,
+                    source: "additional-message-middleware"
+                }
+            }));
+            return input;
+        }
+    });
+exports.additionalMessageMiddleware = __webpack_exports__.additionalMessageMiddleware;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "additionalMessageMiddleware"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/additional-messages.d.ts

@@ -0,0 +1,7 @@
+import { type AgentMiddleware } from "langchain";
+type AdditionalMessageContext = {
+    workdir?: string | null;
+    defaultOutputDir?: string | null;
+};
+export declare const additionalMessageMiddleware: (context?: AdditionalMessageContext) => AgentMiddleware;
+export {};

package/dist/agent/middleware/additional-messages.js

@@ -0,0 +1,26 @@
+import { HumanMessage, MIDDLEWARE_BRAND } from "langchain";
+import { getMachineDetails } from "../utils.js";
+const additionalMessageMiddleware = (context = {})=>({
+        name: "additional-message-middleware",
+        [MIDDLEWARE_BRAND]: true,
+        beforeAgent: async (input)=>{
+            const alreadyInjected = input.messages.some((message)=>message?.additional_kwargs?.source === "additional-message-middleware");
+            if (alreadyInjected) return input;
+            const lines = [
+                getMachineDetails(),
+                `** Current Date Time (UTC): ${new Date().toISOString()} **`
+            ];
+            if (context.workdir) lines.push(`** Working directory for outputs: ${context.workdir} **`);
+            else if (context.defaultOutputDir) lines.push(`** No session working directory set. Default output directory: ${context.defaultOutputDir} **`);
+            lines.push("** Long-term memory **\n- Use /memories/ for durable notes across threads.\n- Store stable preferences, project context, decisions, and research notes.\n- Avoid transient logs; keep entries concise and organized.\n- Suggested paths: /memories/preferences.md, /memories/projects/<name>/context.md, /memories/projects/<name>/decisions.md");
+            input.messages.unshift(new HumanMessage({
+                content: lines.join("\n\n"),
+                additional_kwargs: {
+                    ui_hidden: true,
+                    source: "additional-message-middleware"
+                }
+            }));
+            return input;
+        }
+    });
+export { additionalMessageMiddleware };

package/dist/agent/middleware/hooks/executor.cjs

@@ -0,0 +1,137 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    HookExecutor: ()=>HookExecutor
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_input_builder_cjs_namespaceObject = require("./input-builder.cjs");
+const external_matcher_cjs_namespaceObject = require("./matcher.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class HookExecutor {
+    async executeHooksForEvent(eventName, matchers, context, blocking = false) {
+        if (!matchers || 0 === matchers.length) return;
+        const toolName = context.toolCallRequest?.tool?.name;
+        if (!toolName || "string" != typeof toolName) return void this.logger.debug("No tool name in context, skipping hook execution");
+        const hooks = (0, external_matcher_cjs_namespaceObject.findMatchingHooks)(matchers, toolName);
+        if (0 === hooks.length) return void this.logger.debug(`No hooks matched tool: ${toolName}`);
+        this.logger.debug(`Executing ${hooks.length} ${eventName} hooks for tool: ${toolName}`);
+        const hookInput = (0, external_input_builder_cjs_namespaceObject.buildHookInput)(eventName, context);
+        for (const hook of hooks)await this.executeHook(hook, hookInput, eventName, blocking);
+    }
+    async executeStopHooks(stopHooks, context) {
+        if (!stopHooks || 0 === stopHooks.length) return;
+        this.logger.debug(`Executing ${stopHooks.length} Stop hook groups`);
+        const hookInput = (0, external_input_builder_cjs_namespaceObject.buildHookInput)("Stop", context);
+        for (const stopHook of stopHooks)for (const hook of stopHook.hooks)await this.executeHook(hook, hookInput, "Stop", false);
+    }
+    async executeHook(hook, hookInput, eventName, blocking) {
+        const startTime = Date.now();
+        const timeoutMs = 1000 * (hook.timeout || 60);
+        this.logger.debug(`Executing ${eventName} hook: ${hook.command} (timeout: ${hook.timeout || 60}s)`);
+        try {
+            const result = await this.runCommand(hook.command, hookInput, timeoutMs);
+            const duration = Date.now() - startTime;
+            if (result.timedOut) {
+                this.logger.warn(`Hook timed out after ${timeoutMs}ms: ${hook.command}`);
+                if (blocking) throw new Error(`Hook timed out: ${hook.command}`);
+                return;
+            }
+            if (0 === result.exitCode) {
+                this.logger.info(`Hook completed successfully in ${duration}ms: ${hook.command}`);
+                if (result.stdout) this.logger.debug(`Hook stdout: ${result.stdout}`);
+            } else if (2 === result.exitCode) {
+                const errorMsg = result.stderr || `Hook failed with exit code 2: ${hook.command}`;
+                this.logger.error(`Blocking hook error: ${errorMsg}`);
+                throw new Error(errorMsg);
+            } else {
+                const errorMsg = result.stderr || `Hook failed with exit code ${result.exitCode}: ${hook.command}`;
+                this.logger.warn(`Hook failed (non-blocking): ${errorMsg}`);
+                if (blocking) throw new Error(errorMsg);
+            }
+        } catch (error) {
+            const duration = Date.now() - startTime;
+            this.logger.error(`Hook execution error after ${duration}ms: ${error instanceof Error ? error.message : String(error)}`);
+            if (blocking) throw error;
+        }
+    }
+    runCommand(command, input, timeoutMs) {
+        return new Promise((resolve)=>{
+            const inputJson = JSON.stringify(input);
+            const child = (0, external_node_child_process_namespaceObject.spawn)(command, {
+                cwd: this.workspace,
+                shell: true,
+                timeout: timeoutMs
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            child.stdout?.on("data", (data)=>{
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data)=>{
+                stderr += data.toString();
+            });
+            child.on("error", (error)=>{
+                if (error.message.includes("ETIMEDOUT")) timedOut = true;
+            });
+            child.on("exit", (code)=>{
+                resolve({
+                    success: 0 === code,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                    exitCode: code || void 0,
+                    timedOut
+                });
+            });
+            if (child.stdin) {
+                child.stdin.write(inputJson);
+                child.stdin.end();
+            }
+        });
+    }
+    constructor(workspace, logger){
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "logger", void 0);
+        this.workspace = workspace;
+        this.logger = logger;
+    }
+}
+exports.HookExecutor = __webpack_exports__.HookExecutor;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HookExecutor"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/hooks/executor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Hook Executor
+ *
+ * Core execution engine for running hooks at lifecycle points
+ * Handles command execution, timeout enforcement, and exit code handling
+ */
+import type { HookMatcher, StopHook } from "@/types/hooks.js";
+import type { HookExecutionContext } from "./types.js";
+import type { Logger } from "@/logger.js";
+/**
+ * Hook executor class
+ * Manages hook execution with proper error handling and timeout enforcement
+ */
+export declare class HookExecutor {
+    private workspace;
+    private logger;
+    constructor(workspace: string, logger: Logger);
+    /**
+     * Execute hooks for a specific event with tool filtering
+     *
+     * @param eventName - The hook event name
+     * @param matchers - Array of hook matchers (for PreToolUse/PostToolUse)
+     * @param context - Execution context
+     * @param blocking - Whether hook failures should block execution (PreToolUse only)
+     */
+    executeHooksForEvent(eventName: "PreToolUse" | "PostToolUse", matchers: HookMatcher[] | undefined, context: HookExecutionContext, blocking?: boolean): Promise<void>;
+    /**
+     * Execute Stop hooks (no filtering needed)
+     *
+     * @param stopHooks - Array of Stop hook configurations
+     * @param context - Execution context
+     */
+    executeStopHooks(stopHooks: StopHook[] | undefined, context: HookExecutionContext): Promise<void>;
+    /**
+     * Execute a single hook command
+     *
+     * @param hook - The hook configuration
+     * @param hookInput - Input data to pass via stdin
+     * @param eventName - The event name (for logging)
+     * @param blocking - Whether failures should throw errors
+     */
+    private executeHook;
+    /**
+     * Run a shell command with JSON input via stdin
+     *
+     * @param command - The command to execute
+     * @param input - JSON input to pass via stdin
+     * @param timeoutMs - Timeout in milliseconds
+     * @returns Execution result with stdout/stderr/exitCode
+     */
+    private runCommand;
+}

package/dist/agent/middleware/hooks/executor.js

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+import { buildHookInput } from "./input-builder.js";
+import { findMatchingHooks } from "./matcher.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class HookExecutor {
+    async executeHooksForEvent(eventName, matchers, context, blocking = false) {
+        if (!matchers || 0 === matchers.length) return;
+        const toolName = context.toolCallRequest?.tool?.name;
+        if (!toolName || "string" != typeof toolName) return void this.logger.debug("No tool name in context, skipping hook execution");
+        const hooks = findMatchingHooks(matchers, toolName);
+        if (0 === hooks.length) return void this.logger.debug(`No hooks matched tool: ${toolName}`);
+        this.logger.debug(`Executing ${hooks.length} ${eventName} hooks for tool: ${toolName}`);
+        const hookInput = buildHookInput(eventName, context);
+        for (const hook of hooks)await this.executeHook(hook, hookInput, eventName, blocking);
+    }
+    async executeStopHooks(stopHooks, context) {
+        if (!stopHooks || 0 === stopHooks.length) return;
+        this.logger.debug(`Executing ${stopHooks.length} Stop hook groups`);
+        const hookInput = buildHookInput("Stop", context);
+        for (const stopHook of stopHooks)for (const hook of stopHook.hooks)await this.executeHook(hook, hookInput, "Stop", false);
+    }
+    async executeHook(hook, hookInput, eventName, blocking) {
+        const startTime = Date.now();
+        const timeoutMs = 1000 * (hook.timeout || 60);
+        this.logger.debug(`Executing ${eventName} hook: ${hook.command} (timeout: ${hook.timeout || 60}s)`);
+        try {
+            const result = await this.runCommand(hook.command, hookInput, timeoutMs);
+            const duration = Date.now() - startTime;
+            if (result.timedOut) {
+                this.logger.warn(`Hook timed out after ${timeoutMs}ms: ${hook.command}`);
+                if (blocking) throw new Error(`Hook timed out: ${hook.command}`);
+                return;
+            }
+            if (0 === result.exitCode) {
+                this.logger.info(`Hook completed successfully in ${duration}ms: ${hook.command}`);
+                if (result.stdout) this.logger.debug(`Hook stdout: ${result.stdout}`);
+            } else if (2 === result.exitCode) {
+                const errorMsg = result.stderr || `Hook failed with exit code 2: ${hook.command}`;
+                this.logger.error(`Blocking hook error: ${errorMsg}`);
+                throw new Error(errorMsg);
+            } else {
+                const errorMsg = result.stderr || `Hook failed with exit code ${result.exitCode}: ${hook.command}`;
+                this.logger.warn(`Hook failed (non-blocking): ${errorMsg}`);
+                if (blocking) throw new Error(errorMsg);
+            }
+        } catch (error) {
+            const duration = Date.now() - startTime;
+            this.logger.error(`Hook execution error after ${duration}ms: ${error instanceof Error ? error.message : String(error)}`);
+            if (blocking) throw error;
+        }
+    }
+    runCommand(command, input, timeoutMs) {
+        return new Promise((resolve)=>{
+            const inputJson = JSON.stringify(input);
+            const child = spawn(command, {
+                cwd: this.workspace,
+                shell: true,
+                timeout: timeoutMs
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            child.stdout?.on("data", (data)=>{
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data)=>{
+                stderr += data.toString();
+            });
+            child.on("error", (error)=>{
+                if (error.message.includes("ETIMEDOUT")) timedOut = true;
+            });
+            child.on("exit", (code)=>{
+                resolve({
+                    success: 0 === code,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                    exitCode: code || void 0,
+                    timedOut
+                });
+            });
+            if (child.stdin) {
+                child.stdin.write(inputJson);
+                child.stdin.end();
+            }
+        });
+    }
+    constructor(workspace, logger){
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "logger", void 0);
+        this.workspace = workspace;
+        this.logger = logger;
+    }
+}
+export { HookExecutor };

package/dist/agent/middleware/hooks/input-builder.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildHookInput: ()=>buildHookInput
+});
+function buildHookInput(eventName, context) {
+    const input = {
+        session_id: context.sessionId,
+        cwd: context.cwd,
+        hook_event_name: eventName
+    };
+    if ("PreToolUse" === eventName || "PostToolUse" === eventName) {
+        if (context.toolCallRequest?.tool) {
+            const { tool, toolCall } = context.toolCallRequest;
+            input.tool_name = String(tool.name);
+            input.tool_use_id = toolCall.id;
+            if (toolCall.args) input.tool_input = toolCall.args;
+        }
+    }
+    if ("PostToolUse" === eventName && context.toolResult) {
+        const content = context.toolResult.content;
+        input.tool_output = "string" == typeof content ? content : content;
+    }
+    return input;
+}
+exports.buildHookInput = __webpack_exports__.buildHookInput;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildHookInput"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/hooks/input-builder.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hook Input Builder
+ *
+ * Constructs JSON input data for hooks following Claude Code's HookInput format
+ */
+import type { HookInput, HookEventName } from "@/types/hooks.js";
+import type { HookExecutionContext } from "./types.js";
+/**
+ * Build hook input JSON from execution context
+ *
+ * @param eventName - The hook event name
+ * @param context - The execution context containing all runtime data
+ * @returns HookInput object to be serialized and passed to hook via stdin
+ */
+export declare function buildHookInput(eventName: HookEventName, context: HookExecutionContext): HookInput;

package/dist/agent/middleware/hooks/input-builder.js

@@ -0,0 +1,21 @@
+function buildHookInput(eventName, context) {
+    const input = {
+        session_id: context.sessionId,
+        cwd: context.cwd,
+        hook_event_name: eventName
+    };
+    if ("PreToolUse" === eventName || "PostToolUse" === eventName) {
+        if (context.toolCallRequest?.tool) {
+            const { tool, toolCall } = context.toolCallRequest;
+            input.tool_name = String(tool.name);
+            input.tool_use_id = toolCall.id;
+            if (toolCall.args) input.tool_input = toolCall.args;
+        }
+    }
+    if ("PostToolUse" === eventName && context.toolResult) {
+        const content = context.toolResult.content;
+        input.tool_output = "string" == typeof content ? content : content;
+    }
+    return input;
+}
+export { buildHookInput };

package/dist/agent/middleware/hooks/matcher.cjs

@@ -0,0 +1,59 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    findMatchingHooks: ()=>findMatchingHooks,
+    matchesToolPattern: ()=>matchesToolPattern
+});
+function matchesToolPattern(toolName, pattern) {
+    if (!pattern || "" === pattern) return true;
+    if ("*" === pattern) return true;
+    if (pattern.includes("|")) {
+        const toolNames = pattern.split("|").map((t)=>t.trim());
+        return toolNames.includes(toolName);
+    }
+    if (pattern === toolName) return true;
+    try {
+        const regex = new RegExp(pattern);
+        return regex.test(toolName);
+    } catch (error) {
+        return pattern === toolName;
+    }
+}
+function findMatchingHooks(matchers, toolName) {
+    if (!matchers || 0 === matchers.length) return [];
+    const matchingHooks = [];
+    for (const matcher of matchers)if (matchesToolPattern(toolName, matcher.matcher)) matchingHooks.push(...matcher.hooks);
+    return matchingHooks;
+}
+exports.findMatchingHooks = __webpack_exports__.findMatchingHooks;
+exports.matchesToolPattern = __webpack_exports__.matchesToolPattern;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "findMatchingHooks",
+    "matchesToolPattern"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/hooks/matcher.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pattern Matching Utilities for Hooks
+ *
+ * Implements tool name pattern matching following Claude Code's behavior:
+ * - Pipe-separated tool names: "write_file|edit_file"
+ * - Wildcard: "*" or empty string
+ * - Regex patterns: ".*_file"
+ * - Case-sensitive matching
+ */
+import type { HookMatcher } from "@/types/hooks.js";
+import type { Hook } from "@/types/hooks.js";
+/**
+ * Check if a tool name matches a pattern
+ *
+ * @param toolName - The tool name to match (e.g., "write_file")
+ * @param pattern - The pattern to match against
+ * @returns true if the tool name matches the pattern
+ */
+export declare function matchesToolPattern(toolName: string, pattern?: string): boolean;
+/**
+ * Find all hooks that match a given tool name
+ *
+ * @param matchers - Array of hook matchers to search
+ * @param toolName - The tool name to match
+ * @returns Array of all matching hooks (flattened)
+ */
+export declare function findMatchingHooks(matchers: HookMatcher[] | undefined, toolName: string): Hook[];

package/dist/agent/middleware/hooks/matcher.js

@@ -0,0 +1,22 @@
+function matchesToolPattern(toolName, pattern) {
+    if (!pattern || "" === pattern) return true;
+    if ("*" === pattern) return true;
+    if (pattern.includes("|")) {
+        const toolNames = pattern.split("|").map((t)=>t.trim());
+        return toolNames.includes(toolName);
+    }
+    if (pattern === toolName) return true;
+    try {
+        const regex = new RegExp(pattern);
+        return regex.test(toolName);
+    } catch (error) {
+        return pattern === toolName;
+    }
+}
+function findMatchingHooks(matchers, toolName) {
+    if (!matchers || 0 === matchers.length) return [];
+    const matchingHooks = [];
+    for (const matcher of matchers)if (matchesToolPattern(toolName, matcher.matcher)) matchingHooks.push(...matcher.hooks);
+    return matchingHooks;
+}
+export { findMatchingHooks, matchesToolPattern };