@wingman-ai/gateway 0.1.0

package/dist/tests/hooks-matcher.test.cjs

@@ -0,0 +1,309 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const matcher_cjs_namespaceObject = require("../agent/middleware/hooks/matcher.cjs");
+(0, external_vitest_namespaceObject.describe)("Hooks Pattern Matching", ()=>{
+    (0, external_vitest_namespaceObject.describe)("matchesToolPattern", ()=>{
+        (0, external_vitest_namespaceObject.describe)("Wildcard patterns", ()=>{
+            (0, external_vitest_namespaceObject.it)("should match all tools with wildcard *", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "*")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", "*")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("any_tool", "*")).toBe(true);
+            });
+            (0, external_vitest_namespaceObject.it)("should match all tools with empty string", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", "")).toBe(true);
+            });
+            (0, external_vitest_namespaceObject.it)("should match all tools with undefined pattern", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", void 0)).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", void 0)).toBe(true);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Exact match", ()=>{
+            (0, external_vitest_namespaceObject.it)("should match exact tool name", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "write_file")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", "read_file")).toBe(true);
+            });
+            (0, external_vitest_namespaceObject.it)("should not match different tool names", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "read_file")).toBe(false);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", "write_file")).toBe(false);
+            });
+            (0, external_vitest_namespaceObject.it)("should be case-sensitive", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "WRITE_FILE")).toBe(false);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("Write_File", "write_file")).toBe(false);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Pipe-separated lists", ()=>{
+            (0, external_vitest_namespaceObject.it)("should match any tool in pipe-separated list", ()=>{
+                const pattern = "write_file|read_file|edit_file";
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", pattern)).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", pattern)).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("edit_file", pattern)).toBe(true);
+            });
+            (0, external_vitest_namespaceObject.it)("should not match tools not in the list", ()=>{
+                const pattern = "write_file|read_file";
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("delete_file", pattern)).toBe(false);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("search", pattern)).toBe(false);
+            });
+            (0, external_vitest_namespaceObject.it)("should handle whitespace around pipe separators", ()=>{
+                const pattern = "write_file | read_file | edit_file";
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", pattern)).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", pattern)).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("edit_file", pattern)).toBe(true);
+            });
+            (0, external_vitest_namespaceObject.it)("should handle single item in pipe-separated list", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "write_file|")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "|write_file")).toBe(true);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Regex patterns", ()=>{
+            (0, external_vitest_namespaceObject.it)("should match regex patterns", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", ".*_file")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", ".*_file")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("delete_file", ".*_file")).toBe(true);
+            });
+            (0, external_vitest_namespaceObject.it)("should not match when regex doesn't match", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("search", ".*_file")).toBe(false);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("internet_search", ".*_file")).toBe(false);
+            });
+            (0, external_vitest_namespaceObject.it)("should handle complex regex patterns", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file", "^write_.*")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_code", "^write_.*")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("read_file", "^write_.*")).toBe(false);
+            });
+            (0, external_vitest_namespaceObject.it)("should handle character classes in regex", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write1_file", "write[0-9]_file")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write2_file", "write[0-9]_file")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("writeA_file", "write[0-9]_file")).toBe(false);
+            });
+            (0, external_vitest_namespaceObject.it)("should fallback to exact match for invalid regex", ()=>{
+                const invalidPattern = "[invalid(regex";
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)(invalidPattern, invalidPattern)).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("other_tool", invalidPattern)).toBe(false);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Edge cases", ()=>{
+            (0, external_vitest_namespaceObject.it)("should handle empty tool name", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("", "*")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("", "")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("", "write_file")).toBe(false);
+            });
+            (0, external_vitest_namespaceObject.it)("should handle special characters in tool names", ()=>{
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write_file-v2", "write_file-v2")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write.file", "write.file")).toBe(true);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.matchesToolPattern)("write$file", "write$file")).toBe(true);
+            });
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("findMatchingHooks", ()=>{
+        const mockHook1 = {
+            type: "command",
+            command: "echo 'hook1'",
+            timeout: 30
+        };
+        const mockHook2 = {
+            type: "command",
+            command: "echo 'hook2'",
+            timeout: 60
+        };
+        const mockHook3 = {
+            type: "command",
+            command: "echo 'hook3'"
+        };
+        (0, external_vitest_namespaceObject.describe)("Basic matching", ()=>{
+            (0, external_vitest_namespaceObject.it)("should return empty array when no matchers provided", ()=>{
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(void 0, "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toEqual([]);
+            });
+            (0, external_vitest_namespaceObject.it)("should return empty array when matchers array is empty", ()=>{
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)([], "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toEqual([]);
+            });
+            (0, external_vitest_namespaceObject.it)("should return hooks that match the tool name", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)(result[0]).toBe(mockHook1);
+            });
+            (0, external_vitest_namespaceObject.it)("should return empty array when no matchers match", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    },
+                    {
+                        matcher: "edit_file",
+                        hooks: [
+                            mockHook2
+                        ]
+                    }
+                ];
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "read_file");
+                (0, external_vitest_namespaceObject.expect)(result).toEqual([]);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Multiple matches", ()=>{
+            (0, external_vitest_namespaceObject.it)("should return hooks from multiple matchers", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    },
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook2
+                        ]
+                    }
+                ];
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toHaveLength(2);
+                (0, external_vitest_namespaceObject.expect)(result).toContain(mockHook1);
+                (0, external_vitest_namespaceObject.expect)(result).toContain(mockHook2);
+            });
+            (0, external_vitest_namespaceObject.it)("should return all hooks from a matcher with multiple hooks", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1,
+                            mockHook2,
+                            mockHook3
+                        ]
+                    }
+                ];
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toHaveLength(3);
+                (0, external_vitest_namespaceObject.expect)(result).toContain(mockHook1);
+                (0, external_vitest_namespaceObject.expect)(result).toContain(mockHook2);
+                (0, external_vitest_namespaceObject.expect)(result).toContain(mockHook3);
+            });
+            (0, external_vitest_namespaceObject.it)("should flatten hooks from multiple matching matchers", ()=>{
+                const matchers = [
+                    {
+                        matcher: ".*_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    },
+                    {
+                        matcher: "write_file|read_file",
+                        hooks: [
+                            mockHook2
+                        ]
+                    },
+                    {
+                        matcher: "*",
+                        hooks: [
+                            mockHook3
+                        ]
+                    }
+                ];
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toHaveLength(3);
+                (0, external_vitest_namespaceObject.expect)(result[0]).toBe(mockHook1);
+                (0, external_vitest_namespaceObject.expect)(result[1]).toBe(mockHook2);
+                (0, external_vitest_namespaceObject.expect)(result[2]).toBe(mockHook3);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Pattern types", ()=>{
+            (0, external_vitest_namespaceObject.it)("should match with wildcard pattern", ()=>{
+                const matchers = [
+                    {
+                        matcher: "*",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file")).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "read_file")).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "any_tool")).toHaveLength(1);
+            });
+            (0, external_vitest_namespaceObject.it)("should match with pipe-separated list", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file|read_file|edit_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file")).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "read_file")).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "delete_file")).toHaveLength(0);
+            });
+            (0, external_vitest_namespaceObject.it)("should match with regex pattern", ()=>{
+                const matchers = [
+                    {
+                        matcher: ".*_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file")).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "read_file")).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)((0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "search")).toHaveLength(0);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Order preservation", ()=>{
+            (0, external_vitest_namespaceObject.it)("should preserve order of hooks from matchers", ()=>{
+                const matchers = [
+                    {
+                        matcher: "*",
+                        hooks: [
+                            mockHook1,
+                            mockHook2
+                        ]
+                    },
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook3
+                        ]
+                    }
+                ];
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toHaveLength(3);
+                (0, external_vitest_namespaceObject.expect)(result[0]).toBe(mockHook1);
+                (0, external_vitest_namespaceObject.expect)(result[1]).toBe(mockHook2);
+                (0, external_vitest_namespaceObject.expect)(result[2]).toBe(mockHook3);
+            });
+        });
+        (0, external_vitest_namespaceObject.describe)("Empty hook arrays", ()=>{
+            (0, external_vitest_namespaceObject.it)("should handle matchers with empty hook arrays", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: []
+                    },
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                const result = (0, matcher_cjs_namespaceObject.findMatchingHooks)(matchers, "write_file");
+                (0, external_vitest_namespaceObject.expect)(result).toHaveLength(1);
+                (0, external_vitest_namespaceObject.expect)(result[0]).toBe(mockHook1);
+            });
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/hooks-matcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/hooks-matcher.test.js

@@ -0,0 +1,303 @@
+import { describe, expect, it } from "vitest";
+import { findMatchingHooks, matchesToolPattern } from "../agent/middleware/hooks/matcher.js";
+describe("Hooks Pattern Matching", ()=>{
+    describe("matchesToolPattern", ()=>{
+        describe("Wildcard patterns", ()=>{
+            it("should match all tools with wildcard *", ()=>{
+                expect(matchesToolPattern("write_file", "*")).toBe(true);
+                expect(matchesToolPattern("read_file", "*")).toBe(true);
+                expect(matchesToolPattern("any_tool", "*")).toBe(true);
+            });
+            it("should match all tools with empty string", ()=>{
+                expect(matchesToolPattern("write_file", "")).toBe(true);
+                expect(matchesToolPattern("read_file", "")).toBe(true);
+            });
+            it("should match all tools with undefined pattern", ()=>{
+                expect(matchesToolPattern("write_file", void 0)).toBe(true);
+                expect(matchesToolPattern("read_file", void 0)).toBe(true);
+            });
+        });
+        describe("Exact match", ()=>{
+            it("should match exact tool name", ()=>{
+                expect(matchesToolPattern("write_file", "write_file")).toBe(true);
+                expect(matchesToolPattern("read_file", "read_file")).toBe(true);
+            });
+            it("should not match different tool names", ()=>{
+                expect(matchesToolPattern("write_file", "read_file")).toBe(false);
+                expect(matchesToolPattern("read_file", "write_file")).toBe(false);
+            });
+            it("should be case-sensitive", ()=>{
+                expect(matchesToolPattern("write_file", "WRITE_FILE")).toBe(false);
+                expect(matchesToolPattern("Write_File", "write_file")).toBe(false);
+            });
+        });
+        describe("Pipe-separated lists", ()=>{
+            it("should match any tool in pipe-separated list", ()=>{
+                const pattern = "write_file|read_file|edit_file";
+                expect(matchesToolPattern("write_file", pattern)).toBe(true);
+                expect(matchesToolPattern("read_file", pattern)).toBe(true);
+                expect(matchesToolPattern("edit_file", pattern)).toBe(true);
+            });
+            it("should not match tools not in the list", ()=>{
+                const pattern = "write_file|read_file";
+                expect(matchesToolPattern("delete_file", pattern)).toBe(false);
+                expect(matchesToolPattern("search", pattern)).toBe(false);
+            });
+            it("should handle whitespace around pipe separators", ()=>{
+                const pattern = "write_file | read_file | edit_file";
+                expect(matchesToolPattern("write_file", pattern)).toBe(true);
+                expect(matchesToolPattern("read_file", pattern)).toBe(true);
+                expect(matchesToolPattern("edit_file", pattern)).toBe(true);
+            });
+            it("should handle single item in pipe-separated list", ()=>{
+                expect(matchesToolPattern("write_file", "write_file|")).toBe(true);
+                expect(matchesToolPattern("write_file", "|write_file")).toBe(true);
+            });
+        });
+        describe("Regex patterns", ()=>{
+            it("should match regex patterns", ()=>{
+                expect(matchesToolPattern("write_file", ".*_file")).toBe(true);
+                expect(matchesToolPattern("read_file", ".*_file")).toBe(true);
+                expect(matchesToolPattern("delete_file", ".*_file")).toBe(true);
+            });
+            it("should not match when regex doesn't match", ()=>{
+                expect(matchesToolPattern("search", ".*_file")).toBe(false);
+                expect(matchesToolPattern("internet_search", ".*_file")).toBe(false);
+            });
+            it("should handle complex regex patterns", ()=>{
+                expect(matchesToolPattern("write_file", "^write_.*")).toBe(true);
+                expect(matchesToolPattern("write_code", "^write_.*")).toBe(true);
+                expect(matchesToolPattern("read_file", "^write_.*")).toBe(false);
+            });
+            it("should handle character classes in regex", ()=>{
+                expect(matchesToolPattern("write1_file", "write[0-9]_file")).toBe(true);
+                expect(matchesToolPattern("write2_file", "write[0-9]_file")).toBe(true);
+                expect(matchesToolPattern("writeA_file", "write[0-9]_file")).toBe(false);
+            });
+            it("should fallback to exact match for invalid regex", ()=>{
+                const invalidPattern = "[invalid(regex";
+                expect(matchesToolPattern(invalidPattern, invalidPattern)).toBe(true);
+                expect(matchesToolPattern("other_tool", invalidPattern)).toBe(false);
+            });
+        });
+        describe("Edge cases", ()=>{
+            it("should handle empty tool name", ()=>{
+                expect(matchesToolPattern("", "*")).toBe(true);
+                expect(matchesToolPattern("", "")).toBe(true);
+                expect(matchesToolPattern("", "write_file")).toBe(false);
+            });
+            it("should handle special characters in tool names", ()=>{
+                expect(matchesToolPattern("write_file-v2", "write_file-v2")).toBe(true);
+                expect(matchesToolPattern("write.file", "write.file")).toBe(true);
+                expect(matchesToolPattern("write$file", "write$file")).toBe(true);
+            });
+        });
+    });
+    describe("findMatchingHooks", ()=>{
+        const mockHook1 = {
+            type: "command",
+            command: "echo 'hook1'",
+            timeout: 30
+        };
+        const mockHook2 = {
+            type: "command",
+            command: "echo 'hook2'",
+            timeout: 60
+        };
+        const mockHook3 = {
+            type: "command",
+            command: "echo 'hook3'"
+        };
+        describe("Basic matching", ()=>{
+            it("should return empty array when no matchers provided", ()=>{
+                const result = findMatchingHooks(void 0, "write_file");
+                expect(result).toEqual([]);
+            });
+            it("should return empty array when matchers array is empty", ()=>{
+                const result = findMatchingHooks([], "write_file");
+                expect(result).toEqual([]);
+            });
+            it("should return hooks that match the tool name", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                const result = findMatchingHooks(matchers, "write_file");
+                expect(result).toHaveLength(1);
+                expect(result[0]).toBe(mockHook1);
+            });
+            it("should return empty array when no matchers match", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    },
+                    {
+                        matcher: "edit_file",
+                        hooks: [
+                            mockHook2
+                        ]
+                    }
+                ];
+                const result = findMatchingHooks(matchers, "read_file");
+                expect(result).toEqual([]);
+            });
+        });
+        describe("Multiple matches", ()=>{
+            it("should return hooks from multiple matchers", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    },
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook2
+                        ]
+                    }
+                ];
+                const result = findMatchingHooks(matchers, "write_file");
+                expect(result).toHaveLength(2);
+                expect(result).toContain(mockHook1);
+                expect(result).toContain(mockHook2);
+            });
+            it("should return all hooks from a matcher with multiple hooks", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1,
+                            mockHook2,
+                            mockHook3
+                        ]
+                    }
+                ];
+                const result = findMatchingHooks(matchers, "write_file");
+                expect(result).toHaveLength(3);
+                expect(result).toContain(mockHook1);
+                expect(result).toContain(mockHook2);
+                expect(result).toContain(mockHook3);
+            });
+            it("should flatten hooks from multiple matching matchers", ()=>{
+                const matchers = [
+                    {
+                        matcher: ".*_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    },
+                    {
+                        matcher: "write_file|read_file",
+                        hooks: [
+                            mockHook2
+                        ]
+                    },
+                    {
+                        matcher: "*",
+                        hooks: [
+                            mockHook3
+                        ]
+                    }
+                ];
+                const result = findMatchingHooks(matchers, "write_file");
+                expect(result).toHaveLength(3);
+                expect(result[0]).toBe(mockHook1);
+                expect(result[1]).toBe(mockHook2);
+                expect(result[2]).toBe(mockHook3);
+            });
+        });
+        describe("Pattern types", ()=>{
+            it("should match with wildcard pattern", ()=>{
+                const matchers = [
+                    {
+                        matcher: "*",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                expect(findMatchingHooks(matchers, "write_file")).toHaveLength(1);
+                expect(findMatchingHooks(matchers, "read_file")).toHaveLength(1);
+                expect(findMatchingHooks(matchers, "any_tool")).toHaveLength(1);
+            });
+            it("should match with pipe-separated list", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file|read_file|edit_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                expect(findMatchingHooks(matchers, "write_file")).toHaveLength(1);
+                expect(findMatchingHooks(matchers, "read_file")).toHaveLength(1);
+                expect(findMatchingHooks(matchers, "delete_file")).toHaveLength(0);
+            });
+            it("should match with regex pattern", ()=>{
+                const matchers = [
+                    {
+                        matcher: ".*_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                expect(findMatchingHooks(matchers, "write_file")).toHaveLength(1);
+                expect(findMatchingHooks(matchers, "read_file")).toHaveLength(1);
+                expect(findMatchingHooks(matchers, "search")).toHaveLength(0);
+            });
+        });
+        describe("Order preservation", ()=>{
+            it("should preserve order of hooks from matchers", ()=>{
+                const matchers = [
+                    {
+                        matcher: "*",
+                        hooks: [
+                            mockHook1,
+                            mockHook2
+                        ]
+                    },
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook3
+                        ]
+                    }
+                ];
+                const result = findMatchingHooks(matchers, "write_file");
+                expect(result).toHaveLength(3);
+                expect(result[0]).toBe(mockHook1);
+                expect(result[1]).toBe(mockHook2);
+                expect(result[2]).toBe(mockHook3);
+            });
+        });
+        describe("Empty hook arrays", ()=>{
+            it("should handle matchers with empty hook arrays", ()=>{
+                const matchers = [
+                    {
+                        matcher: "write_file",
+                        hooks: []
+                    },
+                    {
+                        matcher: "write_file",
+                        hooks: [
+                            mockHook1
+                        ]
+                    }
+                ];
+                const result = findMatchingHooks(matchers, "write_file");
+                expect(result).toHaveLength(1);
+                expect(result[0]).toBe(mockHook1);
+            });
+        });
+    });
+});