@wingman-ai/gateway 0.5.3 → 0.5.4

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

@@ -1,309 +0,0 @@
-"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

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

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

@@ -1,303 +0,0 @@
-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);
-            });
-        });
-    });
-});