comisai 1.0.10 → 1.0.12

package/node_modules/@comis/core/dist/hooks/hook-strategies.test.js

@@ -1,209 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { BeforeAgentStartResultSchema, BeforeToolCallResultSchema, ToolResultPersistResultSchema, BeforeCompactionResultSchema, mergeBeforeAgentStart, mergeBeforeToolCall, mergeToolResultPersist, mergeBeforeCompaction, } from "./hook-strategies.js";
-// ─── Zod Schema Tests ────────────────────────────────────────────
-describe("BeforeAgentStartResultSchema", () => {
-    it("parses a valid result with all fields", () => {
-        const input = { systemPrompt: "Hello", prependContext: "ctx" };
-        const result = BeforeAgentStartResultSchema.parse(input);
-        expect(result).toEqual(input);
-    });
-    it("parses an empty object (all fields optional)", () => {
-        const result = BeforeAgentStartResultSchema.parse({});
-        expect(result).toEqual({});
-    });
-    it("applies defaults for omitted optional fields", () => {
-        const result = BeforeAgentStartResultSchema.parse({ systemPrompt: "sp" });
-        expect(result.systemPrompt).toBe("sp");
-        expect(result.prependContext).toBeUndefined();
-    });
-    it("rejects extra properties (strictObject)", () => {
-        expect(() => BeforeAgentStartResultSchema.parse({ systemPrompt: "sp", extra: true })).toThrow();
-    });
-    it("rejects wrong types", () => {
-        expect(() => BeforeAgentStartResultSchema.parse({ systemPrompt: 42 })).toThrow();
-    });
-    it("rejects systemPrompt exceeding 50000 chars (CORE-06)", () => {
-        const longString = "a".repeat(50_001);
-        expect(() => BeforeAgentStartResultSchema.parse({ systemPrompt: longString })).toThrow();
-    });
-    it("accepts systemPrompt at exactly 50000 chars (CORE-06)", () => {
-        const maxString = "a".repeat(50_000);
-        const result = BeforeAgentStartResultSchema.parse({ systemPrompt: maxString });
-        expect(result.systemPrompt).toBe(maxString);
-    });
-    it("rejects prependContext exceeding 50000 chars (CORE-06)", () => {
-        const longString = "a".repeat(50_001);
-        expect(() => BeforeAgentStartResultSchema.parse({ prependContext: longString })).toThrow();
-    });
-    it("accepts prependContext at exactly 50000 chars (CORE-06)", () => {
-        const maxString = "a".repeat(50_000);
-        const result = BeforeAgentStartResultSchema.parse({ prependContext: maxString });
-        expect(result.prependContext).toBe(maxString);
-    });
-    it("round-trips: parse then re-parse produces identical output", () => {
-        const input = { systemPrompt: "test", prependContext: "ctx" };
-        const first = BeforeAgentStartResultSchema.parse(input);
-        const second = BeforeAgentStartResultSchema.parse(first);
-        expect(second).toEqual(first);
-    });
-});
-describe("BeforeToolCallResultSchema", () => {
-    it("parses valid result with skip=false equivalent (block=false)", () => {
-        const result = BeforeToolCallResultSchema.parse({ block: false });
-        expect(result.block).toBe(false);
-    });
-    it("parses result with block=true and blockReason", () => {
-        const input = { block: true, blockReason: "unsafe" };
-        const result = BeforeToolCallResultSchema.parse(input);
-        expect(result.block).toBe(true);
-        expect(result.blockReason).toBe("unsafe");
-    });
-    it("parses result with params override", () => {
-        const input = { params: { key: "value" } };
-        const result = BeforeToolCallResultSchema.parse(input);
-        expect(result.params).toEqual({ key: "value" });
-    });
-    it("parses an empty object (all fields optional)", () => {
-        const result = BeforeToolCallResultSchema.parse({});
-        expect(result).toEqual({});
-    });
-    it("rejects extra properties (strictObject)", () => {
-        expect(() => BeforeToolCallResultSchema.parse({ block: true, unknown: "field" })).toThrow();
-    });
-    it("rejects wrong types for block", () => {
-        expect(() => BeforeToolCallResultSchema.parse({ block: "yes" })).toThrow();
-    });
-});
-describe("ToolResultPersistResultSchema", () => {
-    it("parses a valid result", () => {
-        const result = ToolResultPersistResultSchema.parse({ result: "modified output" });
-        expect(result.result).toBe("modified output");
-    });
-    it("parses an empty object (result is optional)", () => {
-        const result = ToolResultPersistResultSchema.parse({});
-        expect(result.result).toBeUndefined();
-    });
-    it("rejects extra properties (strictObject)", () => {
-        expect(() => ToolResultPersistResultSchema.parse({ result: "ok", extra: true })).toThrow();
-    });
-    it("rejects wrong types for result", () => {
-        expect(() => ToolResultPersistResultSchema.parse({ result: 123 })).toThrow();
-    });
-});
-describe("BeforeCompactionResultSchema", () => {
-    it("parses a valid result with cancel=true", () => {
-        const input = { cancel: true, cancelReason: "important data" };
-        const result = BeforeCompactionResultSchema.parse(input);
-        expect(result.cancel).toBe(true);
-        expect(result.cancelReason).toBe("important data");
-    });
-    it("parses an empty object (all fields optional)", () => {
-        const result = BeforeCompactionResultSchema.parse({});
-        expect(result).toEqual({});
-    });
-    it("rejects extra properties (strictObject)", () => {
-        expect(() => BeforeCompactionResultSchema.parse({ cancel: true, unknown: 1 })).toThrow();
-    });
-    it("rejects wrong types for cancel", () => {
-        expect(() => BeforeCompactionResultSchema.parse({ cancel: "true" })).toThrow();
-    });
-});
-// ─── Merge Function Tests ────────────────────────────────────────
-describe("mergeBeforeAgentStart", () => {
-    it("applies last-writer-wins for conflicting fields", () => {
-        const a = { systemPrompt: "first", prependContext: "ctx-a" };
-        const b = { systemPrompt: "second", prependContext: "ctx-b" };
-        const merged = mergeBeforeAgentStart(a, b);
-        expect(merged.systemPrompt).toBe("second");
-        expect(merged.prependContext).toBe("ctx-b");
-    });
-    it("merging with undefined acc preserves next values", () => {
-        const next = { systemPrompt: "sp", prependContext: "ctx" };
-        const merged = mergeBeforeAgentStart(undefined, next);
-        expect(merged).toEqual(next);
-    });
-    it("undefined fields in next fall back to acc values", () => {
-        const acc = { systemPrompt: "keep-this" };
-        const next = { prependContext: "new-ctx" };
-        const merged = mergeBeforeAgentStart(acc, next);
-        expect(merged.systemPrompt).toBe("keep-this");
-        expect(merged.prependContext).toBe("new-ctx");
-    });
-    it("merging multiple results in sequence produces expected final state", () => {
-        const r1 = { systemPrompt: "first" };
-        const r2 = { prependContext: "middle-ctx" };
-        const r3 = { systemPrompt: "final" };
-        let merged = mergeBeforeAgentStart(undefined, r1);
-        merged = mergeBeforeAgentStart(merged, r2);
-        merged = mergeBeforeAgentStart(merged, r3);
-        expect(merged.systemPrompt).toBe("final");
-        expect(merged.prependContext).toBe("middle-ctx");
-    });
-});
-describe("mergeBeforeToolCall", () => {
-    it("applies last-writer-wins for block field", () => {
-        const a = { block: false };
-        const b = { block: true, blockReason: "security" };
-        const merged = mergeBeforeToolCall(a, b);
-        expect(merged.block).toBe(true);
-        expect(merged.blockReason).toBe("security");
-    });
-    it("preserves non-conflicting fields across merges", () => {
-        const a = { params: { key: "val" } };
-        const b = { block: true, blockReason: "unsafe" };
-        const merged = mergeBeforeToolCall(a, b);
-        expect(merged.params).toEqual({ key: "val" });
-        expect(merged.block).toBe(true);
-        expect(merged.blockReason).toBe("unsafe");
-    });
-    it("merging with undefined acc preserves next", () => {
-        const next = { block: true, blockReason: "denied" };
-        const merged = mergeBeforeToolCall(undefined, next);
-        expect(merged).toEqual(next);
-    });
-});
-describe("mergeToolResultPersist", () => {
-    it("applies last-writer-wins for result field", () => {
-        const a = { result: "original" };
-        const b = { result: "modified" };
-        const merged = mergeToolResultPersist(a, b);
-        expect(merged.result).toBe("modified");
-    });
-    it("undefined result in next falls back to acc", () => {
-        const a = { result: "keep" };
-        const b = {};
-        const merged = mergeToolResultPersist(a, b);
-        expect(merged.result).toBe("keep");
-    });
-    it("merging with undefined acc preserves next", () => {
-        const next = { result: "output" };
-        const merged = mergeToolResultPersist(undefined, next);
-        expect(merged.result).toBe("output");
-    });
-});
-describe("mergeBeforeCompaction", () => {
-    it("applies last-writer-wins for cancel field", () => {
-        const a = { cancel: false };
-        const b = { cancel: true, cancelReason: "important" };
-        const merged = mergeBeforeCompaction(a, b);
-        expect(merged.cancel).toBe(true);
-        expect(merged.cancelReason).toBe("important");
-    });
-    it("preserves non-conflicting fields across merges", () => {
-        const a = { cancel: true };
-        const b = { cancelReason: "new-reason" };
-        const merged = mergeBeforeCompaction(a, b);
-        expect(merged.cancel).toBe(true);
-        expect(merged.cancelReason).toBe("new-reason");
-    });
-    it("merging multiple results in sequence", () => {
-        const r1 = { cancel: true, cancelReason: "first" };
-        const r2 = { cancel: false };
-        const r3 = { cancelReason: "final-reason" };
-        let merged = mergeBeforeCompaction(undefined, r1);
-        merged = mergeBeforeCompaction(merged, r2);
-        merged = mergeBeforeCompaction(merged, r3);
-        expect(merged.cancel).toBe(false);
-        expect(merged.cancelReason).toBe("final-reason");
-    });
-});

package/node_modules/@comis/core/dist/hooks/integration.test.d.ts

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

package/node_modules/@comis/core/dist/hooks/integration.test.js

@@ -1,235 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ok } from "@comis/shared";
-import { TypedEventBus } from "../event-bus/index.js";
-import { PluginsConfigSchema } from "../config/schema-plugins.js";
-import { createPluginRegistry } from "./plugin-registry.js";
-import { createHookRunner } from "./hook-runner.js";
-/**
- * Create a minimal test plugin with sensible defaults.
- */
-function createTestPlugin(overrides) {
-    return {
-        name: overrides.name ?? `test-plugin-${overrides.id}`,
-        register: overrides.register ?? ((_api) => ok(undefined)),
-        ...overrides,
-    };
-}
-describe("Hook System Integration", () => {
-    it("full plugin lifecycle: register -> activate -> hook -> deactivate", async () => {
-        // 1. Create a TypedEventBus instance
-        const eventBus = new TypedEventBus();
-        // Collect emitted events for verification
-        const pluginRegisteredEvents = [];
-        const hookExecutedEvents = [];
-        const pluginDeactivatedEvents = [];
-        eventBus.on("plugin:registered", (e) => pluginRegisteredEvents.push(e));
-        eventBus.on("hook:executed", (e) => hookExecutedEvents.push(e));
-        eventBus.on("plugin:deactivated", (e) => pluginDeactivatedEvents.push(e));
-        // 2. Create a plugin registry with the event bus
-        const registry = createPluginRegistry({ eventBus });
-        // 3. Create a hook runner with the registry and event bus
-        const runner = createHookRunner(registry, { eventBus });
-        // 4. Define a test plugin
-        const agentEndCalls = [];
-        const testPlugin = createTestPlugin({
-            id: "lifecycle-test",
-            name: "Lifecycle Test Plugin",
-            register: (api) => {
-                // before_agent_start: modifying hook that prepends "[PLUGIN] " to system prompt
-                api.registerHook("before_agent_start", (event) => ({
-                    systemPrompt: `[PLUGIN] ${event.systemPrompt}`,
-                }));
-                // agent_end: void hook that records the call
-                api.registerHook("agent_end", (event) => {
-                    agentEndCalls.push({ durationMs: event.durationMs, success: event.success });
-                });
-                return ok(undefined);
-            },
-            activate: async () => ok(undefined),
-            deactivate: async () => ok(undefined),
-        });
-        // 5. Register the plugin -> verify ok result
-        const registerResult = registry.register(testPlugin);
-        expect(registerResult.ok).toBe(true);
-        // 6. Activate all plugins -> verify ok result
-        const activateResult = await registry.activateAll();
-        expect(activateResult.ok).toBe(true);
-        // 7. Run before_agent_start hook -> verify system prompt is modified
-        const beforeResult = await runner.runBeforeAgentStart({ systemPrompt: "Be helpful.", messages: [] }, { agentId: "agent-1" });
-        expect(beforeResult?.systemPrompt).toBe("[PLUGIN] Be helpful.");
-        // 8. Run agent_end hook -> verify tracking array has the call
-        await runner.runAgentEnd({ durationMs: 250, success: true }, { agentId: "agent-1" });
-        expect(agentEndCalls).toHaveLength(1);
-        expect(agentEndCalls[0]).toEqual({ durationMs: 250, success: true });
-        // 9. Deactivate all plugins -> verify ok result
-        const deactivateResult = await registry.deactivateAll();
-        expect(deactivateResult.ok).toBe(true);
-        // 10. Verify plugin:registered event was emitted on the event bus
-        expect(pluginRegisteredEvents).toHaveLength(1);
-        expect(pluginRegisteredEvents[0].pluginId).toBe("lifecycle-test");
-        expect(pluginRegisteredEvents[0].hookCount).toBe(2);
-        // 11. Verify hook:executed events were emitted for both hook calls
-        expect(hookExecutedEvents).toHaveLength(2);
-        expect(hookExecutedEvents[0].hookName).toBe("before_agent_start");
-        expect(hookExecutedEvents[1].hookName).toBe("agent_end");
-        expect(hookExecutedEvents.every((e) => e.success)).toBe(true);
-        // Verify deactivation event
-        expect(pluginDeactivatedEvents).toHaveLength(1);
-        expect(pluginDeactivatedEvents[0].pluginId).toBe("lifecycle-test");
-    });
-    it("multiple plugins with priority ordering", async () => {
-        const eventBus = new TypedEventBus();
-        const registry = createPluginRegistry({ eventBus });
-        const runner = createHookRunner(registry, { eventBus });
-        const executionOrder = [];
-        // Plugin A: priority 10 (runs first)
-        registry.register(createTestPlugin({
-            id: "plugin-a",
-            register: (api) => {
-                api.registerHook("before_tool_call", (event) => {
-                    executionOrder.push("A");
-                    return { params: { ...event.params, fromA: true } };
-                }, { priority: 10 });
-                return ok(undefined);
-            },
-        }));
-        // Plugin B: priority 5 (runs second)
-        registry.register(createTestPlugin({
-            id: "plugin-b",
-            register: (api) => {
-                api.registerHook("before_tool_call", (event) => {
-                    executionOrder.push("B");
-                    return { params: { ...event.params, fromB: true } };
-                }, { priority: 5 });
-                return ok(undefined);
-            },
-        }));
-        const result = await runner.runBeforeToolCall({ toolName: "read_file", params: { path: "/tmp" } }, { agentId: "a" });
-        // A ran before B (higher priority first)
-        expect(executionOrder).toEqual(["A", "B"]);
-        // Both modifications present (B's params override A's via merge)
-        expect(result?.params).toBeDefined();
-        expect(result.params.fromB).toBe(true);
-    });
-    it("plugin error isolation", async () => {
-        const eventBus = new TypedEventBus();
-        const registry = createPluginRegistry({ eventBus });
-        const runner = createHookRunner(registry, { eventBus, catchErrors: true });
-        const hookEvents = [];
-        eventBus.on("hook:executed", (e) => hookEvents.push(e));
-        // First plugin: throws an error
-        registry.register(createTestPlugin({
-            id: "broken",
-            register: (api) => {
-                api.registerHook("before_agent_start", () => {
-                    throw new Error("intentional failure");
-                }, { priority: 10 });
-                return ok(undefined);
-            },
-        }));
-        // Second plugin: normal behavior
-        registry.register(createTestPlugin({
-            id: "healthy",
-            register: (api) => {
-                api.registerHook("before_agent_start", () => ({ systemPrompt: "from-healthy" }), { priority: 5 });
-                return ok(undefined);
-            },
-        }));
-        const result = await runner.runBeforeAgentStart({ systemPrompt: "original", messages: [] }, { agentId: "a" });
-        // The second plugin's result is returned (first was caught)
-        expect(result?.systemPrompt).toBe("from-healthy");
-        // Verify hook:executed events
-        expect(hookEvents).toHaveLength(2);
-        const brokenEvent = hookEvents.find((e) => e.pluginId === "broken");
-        expect(brokenEvent?.success).toBe(false);
-        expect(brokenEvent?.error).toBe("intentional failure");
-        const healthyEvent = hookEvents.find((e) => e.pluginId === "healthy");
-        expect(healthyEvent?.success).toBe(true);
-    });
-    it("before_tool_call blocks tool execution", async () => {
-        const registry = createPluginRegistry();
-        const runner = createHookRunner(registry);
-        registry.register(createTestPlugin({
-            id: "security-gate",
-            register: (api) => {
-                api.registerHook("before_tool_call", () => ({
-                    block: true,
-                    blockReason: "forbidden",
-                }));
-                return ok(undefined);
-            },
-        }));
-        const result = await runner.runBeforeToolCall({ toolName: "shell:exec", params: { command: "rm -rf /" } }, { agentId: "a" });
-        expect(result?.block).toBe(true);
-        expect(result?.blockReason).toBe("forbidden");
-    });
-    it("config-driven plugin enablement (schema validation)", () => {
-        // Validate PluginsConfigSchema correctly parses plugin configurations
-        // Parse a config with one enabled and one disabled plugin
-        const config = PluginsConfigSchema.parse({
-            enabled: true,
-            plugins: {
-                "audit-logger": {
-                    enabled: true,
-                    priority: 10,
-                    config: { logLevel: "debug" },
-                },
-                "webhook-forwarder": {
-                    enabled: false,
-                    priority: -5,
-                    config: { url: "https://example.com/webhook" },
-                },
-            },
-        });
-        expect(config.enabled).toBe(true);
-        expect(Object.keys(config.plugins)).toHaveLength(2);
-        const audit = config.plugins["audit-logger"];
-        expect(audit.enabled).toBe(true);
-        expect(audit.priority).toBe(10);
-        expect(audit.config.logLevel).toBe("debug");
-        const webhook = config.plugins["webhook-forwarder"];
-        expect(webhook.enabled).toBe(false);
-        expect(webhook.priority).toBe(-5);
-        // Validate defaults work
-        const defaultConfig = PluginsConfigSchema.parse({});
-        expect(defaultConfig.enabled).toBe(true);
-        expect(Object.keys(defaultConfig.plugins)).toHaveLength(0);
-    });
-    it("lifecycle scenario: unregister/re-register", async () => {
-        const registry = createPluginRegistry();
-        const runner = createHookRunner(registry);
-        // 1. Register a plugin
-        const calls = [];
-        registry.register(createTestPlugin({
-            id: "hot-plugin",
-            register: (api) => {
-                api.registerHook("agent_end", () => {
-                    calls.push("v1");
-                });
-                return ok(undefined);
-            },
-        }));
-        // 2. Run a hook -> verify it fires
-        await runner.runAgentEnd({ durationMs: 100, success: true }, { agentId: "a" });
-        expect(calls).toEqual(["v1"]);
-        // 3. Unregister the plugin
-        const unregResult = registry.unregister("hot-plugin");
-        expect(unregResult.ok).toBe(true);
-        // 4. Run the same hook -> verify it does NOT fire
-        await runner.runAgentEnd({ durationMs: 100, success: true }, { agentId: "a" });
-        expect(calls).toEqual(["v1"]); // still just one call
-        // 5. Register a new plugin for the same hook
-        registry.register(createTestPlugin({
-            id: "hot-plugin-v2",
-            register: (api) => {
-                api.registerHook("agent_end", () => {
-                    calls.push("v2");
-                });
-                return ok(undefined);
-            },
-        }));
-        // 6. Run the hook -> verify the new plugin fires
-        await runner.runAgentEnd({ durationMs: 100, success: true }, { agentId: "a" });
-        expect(calls).toEqual(["v1", "v2"]);
-    });
-});

package/node_modules/@comis/core/dist/hooks/plugin-registry.test.d.ts

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