comisai 1.0.11 → 1.0.13

package/node_modules/@comis/core/dist/event-bus/bus.test.js

@@ -1,152 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { TypedEventBus } from "./bus.js";
-describe("TypedEventBus", () => {
-    it("emit triggers on handler with correct payload", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        bus.on("system:shutdown", handler);
-        bus.emit("system:shutdown", { reason: "test", graceful: true });
-        expect(handler).toHaveBeenCalledOnce();
-        expect(handler).toHaveBeenCalledWith({ reason: "test", graceful: true });
-    });
-    it("once fires only once", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        bus.once("system:shutdown", handler);
-        bus.emit("system:shutdown", { reason: "first", graceful: true });
-        bus.emit("system:shutdown", { reason: "second", graceful: false });
-        expect(handler).toHaveBeenCalledOnce();
-        expect(handler).toHaveBeenCalledWith({ reason: "first", graceful: true });
-    });
-    it("off removes handler", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        bus.on("config:patched", handler);
-        bus.off("config:patched", handler);
-        bus.emit("config:patched", { section: "test", patchedBy: "admin", timestamp: Date.now() });
-        expect(handler).not.toHaveBeenCalled();
-    });
-    it("removeAllListeners works for specific event", () => {
-        const bus = new TypedEventBus();
-        const handler1 = vi.fn();
-        const handler2 = vi.fn();
-        const otherHandler = vi.fn();
-        bus.on("system:shutdown", handler1);
-        bus.on("system:shutdown", handler2);
-        bus.on("system:error", otherHandler);
-        bus.removeAllListeners("system:shutdown");
-        bus.emit("system:shutdown", { reason: "test", graceful: true });
-        bus.emit("system:error", { error: new Error("test"), source: "unit-test" });
-        expect(handler1).not.toHaveBeenCalled();
-        expect(handler2).not.toHaveBeenCalled();
-        expect(otherHandler).toHaveBeenCalledOnce();
-    });
-    it("removeAllListeners without argument removes all", () => {
-        const bus = new TypedEventBus();
-        const handler1 = vi.fn();
-        const handler2 = vi.fn();
-        bus.on("system:shutdown", handler1);
-        bus.on("system:error", handler2);
-        bus.removeAllListeners();
-        bus.emit("system:shutdown", { reason: "test", graceful: true });
-        bus.emit("system:error", { error: new Error("test"), source: "unit-test" });
-        expect(handler1).not.toHaveBeenCalled();
-        expect(handler2).not.toHaveBeenCalled();
-    });
-    it("listenerCount returns correct count", () => {
-        const bus = new TypedEventBus();
-        expect(bus.listenerCount("session:created")).toBe(0);
-        const h1 = vi.fn();
-        const h2 = vi.fn();
-        const h3 = vi.fn();
-        bus.on("session:created", h1);
-        expect(bus.listenerCount("session:created")).toBe(1);
-        bus.on("session:created", h2);
-        bus.on("session:created", h3);
-        expect(bus.listenerCount("session:created")).toBe(3);
-        bus.off("session:created", h2);
-        expect(bus.listenerCount("session:created")).toBe(2);
-    });
-    it("multiple handlers all fire for same event", () => {
-        const bus = new TypedEventBus();
-        const handler1 = vi.fn();
-        const handler2 = vi.fn();
-        const handler3 = vi.fn();
-        bus.on("system:shutdown", handler1);
-        bus.on("system:shutdown", handler2);
-        bus.on("system:shutdown", handler3);
-        bus.emit("system:shutdown", { reason: "multi", graceful: false });
-        expect(handler1).toHaveBeenCalledOnce();
-        expect(handler2).toHaveBeenCalledOnce();
-        expect(handler3).toHaveBeenCalledOnce();
-    });
-    it("handler receives correct typed payload for message:received", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const sessionKey = {
-            tenantId: "tenant-1",
-            userId: "user-1",
-            channelId: "chan-1",
-        };
-        const message = {
-            id: "550e8400-e29b-41d4-a716-446655440000",
-            channelId: "chan-1",
-            channelType: "telegram",
-            senderId: "user-1",
-            text: "Hello, world!",
-            timestamp: Date.now(),
-            attachments: [],
-            metadata: {},
-        };
-        bus.on("message:received", handler);
-        bus.emit("message:received", { message, sessionKey });
-        expect(handler).toHaveBeenCalledWith({ message, sessionKey });
-        const received = handler.mock.calls[0][0];
-        expect(received.message.text).toBe("Hello, world!");
-        expect(received.sessionKey.tenantId).toBe("tenant-1");
-    });
-    it("handler receives correct typed payload for audit:event", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const auditPayload = {
-            timestamp: Date.now(),
-            agentId: "agent-1",
-            tenantId: "tenant-1",
-            actionType: "tool:execute",
-            classification: "high-risk",
-            outcome: "denied",
-            metadata: { tool: "shell:exec", reason: "sandbox violation" },
-        };
-        bus.on("audit:event", handler);
-        bus.emit("audit:event", auditPayload);
-        expect(handler).toHaveBeenCalledWith(auditPayload);
-        const received = handler.mock.calls[0][0];
-        expect(received.outcome).toBe("denied");
-        expect(received.metadata?.tool).toBe("shell:exec");
-    });
-    it("type safety: @ts-expect-error for wrong payload types", () => {
-        const bus = new TypedEventBus();
-        // Correct usage compiles fine
-        bus.emit("system:shutdown", { reason: "ok", graceful: true });
-        // @ts-expect-error - missing required "graceful" field
-        bus.emit("system:shutdown", { reason: "missing-field" });
-        // @ts-expect-error - wrong type for "graceful" (string instead of boolean)
-        bus.emit("system:shutdown", { reason: "wrong-type", graceful: "yes" });
-        // @ts-expect-error - nonexistent event name
-        bus.emit("nonexistent:event", { foo: "bar" });
-    });
-    it("methods return this for chaining", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const result = bus.on("system:shutdown", handler);
-        expect(result).toBe(bus);
-        const result2 = bus.off("system:shutdown", handler);
-        expect(result2).toBe(bus);
-        const result3 = bus.once("system:shutdown", handler);
-        expect(result3).toBe(bus);
-        const result4 = bus.removeAllListeners("system:shutdown");
-        expect(result4).toBe(bus);
-        const result5 = bus.setMaxListeners(20);
-        expect(result5).toBe(bus);
-    });
-});

package/node_modules/@comis/core/dist/event-bus/events-agent.test.d.ts

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

package/node_modules/@comis/core/dist/event-bus/events-agent.test.js

@@ -1,409 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { TypedEventBus } from "./bus.js";
-describe("AgentEvents payload structure", () => {
-    it("skill:loaded delivers skillName, source, timestamp", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            skillName: "greet",
-            source: "/skills/greet.md",
-            timestamp: Date.now(),
-        };
-        bus.on("skill:loaded", handler);
-        bus.emit("skill:loaded", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.skillName).toBe("greet");
-        expect(received.source).toBe("/skills/greet.md");
-    });
-    it("skill:executed delivers durationMs and success boolean", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            skillName: "summarize",
-            durationMs: 42,
-            success: true,
-            timestamp: Date.now(),
-        };
-        bus.on("skill:executed", handler);
-        bus.emit("skill:executed", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.durationMs).toBe(42);
-        expect(received.success).toBe(true);
-    });
-    it("skill:rejected delivers violations string array", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            skillName: "exploit",
-            reason: "security scan failed",
-            violations: ["eval() usage", "network access"],
-            timestamp: Date.now(),
-        };
-        bus.on("skill:rejected", handler);
-        bus.emit("skill:rejected", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.violations).toEqual(["eval() usage", "network access"]);
-    });
-    it("skill:prompt_invoked delivers invokedBy union", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        for (const invokedBy of ["user", "model"]) {
-            const payload = {
-                skillName: "translate",
-                invokedBy,
-                args: "--lang=fr",
-                timestamp: Date.now(),
-            };
-            bus.on("skill:prompt_invoked", handler);
-            bus.emit("skill:prompt_invoked", payload);
-            bus.removeAllListeners("skill:prompt_invoked");
-        }
-        expect(handler).toHaveBeenCalledTimes(2);
-        expect(handler.mock.calls[0][0].invokedBy).toBe("user");
-        expect(handler.mock.calls[1][0].invokedBy).toBe("model");
-    });
-    it("tool:executed delivers required and optional fields", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        // With all optional fields
-        const fullPayload = {
-            toolName: "bash",
-            durationMs: 350,
-            success: false,
-            timestamp: Date.now(),
-            userId: "user-1",
-            traceId: "trace-abc",
-            agentId: "agent-1",
-            sessionKey: "t1:u1:c1",
-            params: { command: "ls" },
-            errorMessage: "Permission denied",
-            errorKind: "internal",
-            description: "Test run",
-        };
-        bus.on("tool:executed", handler);
-        bus.emit("tool:executed", fullPayload);
-        expect(handler).toHaveBeenCalledWith(fullPayload);
-        const received = handler.mock.calls[0][0];
-        expect(received.toolName).toBe("bash");
-        expect(received.success).toBe(false);
-        expect(received.errorMessage).toBe("Permission denied");
-        expect(received.errorKind).toBe("internal");
-        expect(received.userId).toBe("user-1");
-        expect(received.traceId).toBe("trace-abc");
-        expect(received.description).toBe("Test run");
-        // With only required fields
-        const minPayload = {
-            toolName: "file_ops",
-            durationMs: 5,
-            success: true,
-            timestamp: Date.now(),
-        };
-        bus.emit("tool:executed", minPayload);
-        expect(handler).toHaveBeenCalledTimes(2);
-        expect(handler.mock.calls[1][0].errorMessage).toBeUndefined();
-    });
-    it("tool:executed delivers truncation metadata fields (Phase 558)", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        // With truncation metadata (per-tool or per-turn budget truncation)
-        const truncatedPayload = {
-            toolName: "bash",
-            durationMs: 150,
-            success: true,
-            timestamp: Date.now(),
-            truncated: true,
-            fullChars: 500_000,
-            returnedChars: 200_000,
-        };
-        bus.on("tool:executed", handler);
-        bus.emit("tool:executed", truncatedPayload);
-        const received = handler.mock.calls[0][0];
-        expect(received.truncated).toBe(true);
-        expect(received.fullChars).toBe(500_000);
-        expect(received.returnedChars).toBe(200_000);
-        // Without truncation metadata (normal execution)
-        const normalPayload = {
-            toolName: "read",
-            durationMs: 10,
-            success: true,
-            timestamp: Date.now(),
-        };
-        bus.emit("tool:executed", normalPayload);
-        expect(handler).toHaveBeenCalledTimes(2);
-        const normalReceived = handler.mock.calls[1][0];
-        expect(normalReceived.truncated).toBeUndefined();
-        expect(normalReceived.fullChars).toBeUndefined();
-        expect(normalReceived.returnedChars).toBeUndefined();
-    });
-    it("tool:started delivers description field", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            toolName: "exec",
-            toolCallId: "tc-desc",
-            timestamp: Date.now(),
-            agentId: "agent-1",
-            description: "Installing packages",
-        };
-        bus.on("tool:started", handler);
-        bus.emit("tool:started", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.description).toBe("Installing packages");
-    });
-    it("audit:event delivers outcome union and optional metadata", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        for (const outcome of ["success", "failure", "denied"]) {
-            const payload = {
-                timestamp: Date.now(),
-                agentId: "agent-1",
-                tenantId: "tenant-1",
-                actionType: "tool:execute",
-                classification: "high-risk",
-                outcome,
-                metadata: outcome === "denied" ? { reason: "sandbox violation" } : undefined,
-            };
-            bus.on("audit:event", handler);
-            bus.emit("audit:event", payload);
-            bus.removeAllListeners("audit:event");
-        }
-        expect(handler).toHaveBeenCalledTimes(3);
-        expect(handler.mock.calls[0][0].outcome).toBe("success");
-        expect(handler.mock.calls[2][0].outcome).toBe("denied");
-        expect(handler.mock.calls[2][0].metadata).toEqual({ reason: "sandbox violation" });
-    });
-    it("observability:token_usage delivers nested tokens and cost objects", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            timestamp: Date.now(),
-            traceId: "trace-xyz",
-            agentId: "agent-1",
-            channelId: "c1",
-            executionId: "exec-001",
-            provider: "anthropic",
-            model: "claude-sonnet-4-20250514",
-            tokens: { prompt: 1000, completion: 500, total: 1500 },
-            cost: { input: 0.003, output: 0.015, cacheRead: 0, cacheWrite: 0, total: 0.018 },
-            latencyMs: 2500,
-            cacheReadTokens: 0,
-            cacheWriteTokens: 0,
-            sessionKey: "test-session",
-            savedVsUncached: 0,
-            cacheEligible: true,
-        };
-        bus.on("observability:token_usage", handler);
-        bus.emit("observability:token_usage", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.tokens.prompt).toBe(1000);
-        expect(received.tokens.completion).toBe(500);
-        expect(received.tokens.total).toBe(1500);
-        expect(received.cost.input).toBe(0.003);
-        expect(received.cost.total).toBe(0.018);
-    });
-    it("observability:latency delivers operation union", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        for (const operation of ["llm_call", "tool_execution", "memory_search"]) {
-            const payload = {
-                operation,
-                durationMs: 100,
-                timestamp: Date.now(),
-            };
-            bus.on("observability:latency", handler);
-            bus.emit("observability:latency", payload);
-            bus.removeAllListeners("observability:latency");
-        }
-        expect(handler).toHaveBeenCalledTimes(3);
-        expect(handler.mock.calls[0][0].operation).toBe("llm_call");
-        expect(handler.mock.calls[1][0].operation).toBe("tool_execution");
-        expect(handler.mock.calls[2][0].operation).toBe("memory_search");
-    });
-    it("model:fallback_attempt delivers fromProvider/toProvider and attemptNumber", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            fromProvider: "anthropic",
-            fromModel: "claude-sonnet-4-20250514",
-            toProvider: "openai",
-            toModel: "gpt-4",
-            error: "Rate limit exceeded",
-            attemptNumber: 2,
-            timestamp: Date.now(),
-        };
-        bus.on("model:fallback_attempt", handler);
-        bus.emit("model:fallback_attempt", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.fromProvider).toBe("anthropic");
-        expect(received.toProvider).toBe("openai");
-        expect(received.attemptNumber).toBe(2);
-    });
-    it("security:injection_detected delivers source union, patterns array, riskLevel union", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            timestamp: Date.now(),
-            source: "user_input",
-            patterns: ["ignore previous instructions", "system prompt override"],
-            riskLevel: "high",
-            agentId: "agent-1",
-            sessionKey: "t1:u1:c1",
-            traceId: "trace-sec",
-        };
-        bus.on("security:injection_detected", handler);
-        bus.emit("security:injection_detected", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.source).toBe("user_input");
-        expect(received.patterns).toEqual(["ignore previous instructions", "system prompt override"]);
-        expect(received.riskLevel).toBe("high");
-    });
-    it("security:injection_detected accepts workspace_file source", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            timestamp: Date.now(),
-            source: "workspace_file",
-            patterns: ["HTML_COMMENT_INJECTION"],
-            riskLevel: "high",
-            agentId: "agent-ws",
-        };
-        bus.on("security:injection_detected", handler);
-        bus.emit("security:injection_detected", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.source).toBe("workspace_file");
-    });
-    it("graph:started delivers graphId, nodeCount, optional label", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        // With label
-        const fullPayload = {
-            graphId: "g-001",
-            label: "My Pipeline",
-            nodeCount: 5,
-            timestamp: Date.now(),
-        };
-        bus.on("graph:started", handler);
-        bus.emit("graph:started", fullPayload);
-        expect(handler).toHaveBeenCalledWith(fullPayload);
-        const received = handler.mock.calls[0][0];
-        expect(received.graphId).toBe("g-001");
-        expect(received.label).toBe("My Pipeline");
-        expect(received.nodeCount).toBe(5);
-        // Without label
-        const minPayload = {
-            graphId: "g-002",
-            nodeCount: 1,
-            timestamp: Date.now(),
-        };
-        bus.emit("graph:started", minPayload);
-        expect(handler).toHaveBeenCalledTimes(2);
-        expect(handler.mock.calls[1][0].label).toBeUndefined();
-    });
-    it("graph:node_updated delivers nodeId, status, optional durationMs and error", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        // Completed case (with durationMs)
-        const completedPayload = {
-            graphId: "g-001",
-            nodeId: "A",
-            status: "completed",
-            durationMs: 250,
-            timestamp: Date.now(),
-        };
-        bus.on("graph:node_updated", handler);
-        bus.emit("graph:node_updated", completedPayload);
-        expect(handler).toHaveBeenCalledWith(completedPayload);
-        const received = handler.mock.calls[0][0];
-        expect(received.nodeId).toBe("A");
-        expect(received.status).toBe("completed");
-        expect(received.durationMs).toBe(250);
-        expect(received.error).toBeUndefined();
-        // Failed case (with error + durationMs)
-        const failedPayload = {
-            graphId: "g-001",
-            nodeId: "B",
-            status: "failed",
-            durationMs: 100,
-            error: "Execution timeout",
-            timestamp: Date.now(),
-        };
-        bus.emit("graph:node_updated", failedPayload);
-        expect(handler).toHaveBeenCalledTimes(2);
-        const failedReceived = handler.mock.calls[1][0];
-        expect(failedReceived.status).toBe("failed");
-        expect(failedReceived.error).toBe("Execution timeout");
-        expect(failedReceived.durationMs).toBe(100);
-    });
-    it("graph:completed delivers status, durationMs, and node count breakdown", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            graphId: "g-001",
-            status: "completed",
-            durationMs: 5000,
-            nodeCount: 4,
-            nodesCompleted: 3,
-            nodesFailed: 0,
-            nodesSkipped: 1,
-            timestamp: Date.now(),
-        };
-        bus.on("graph:completed", handler);
-        bus.emit("graph:completed", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.graphId).toBe("g-001");
-        expect(received.status).toBe("completed");
-        expect(received.durationMs).toBe(5000);
-        expect(received.nodeCount).toBe(4);
-        expect(received.nodesCompleted).toBe(3);
-        expect(received.nodesFailed).toBe(0);
-        expect(received.nodesSkipped).toBe(1);
-    });
-    it("type safety: @ts-expect-error for missing required fields", () => {
-        const bus = new TypedEventBus();
-        // @ts-expect-error - missing success in skill:executed
-        bus.emit("skill:executed", { skillName: "x", durationMs: 10, timestamp: 1 });
-        // @ts-expect-error - missing tokens, sessionKey, savedVsUncached, cacheEligible, cacheReadTokens, cacheWriteTokens
-        bus.emit("observability:token_usage", {
-            timestamp: 1, traceId: "t", agentId: "a", channelId: "c",
-            executionId: "e", provider: "p", model: "m",
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, latencyMs: 0,
-        });
-    });
-    it("provider:degraded delivers provider, failingAgents, timestamp", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            provider: "anthropic",
-            failingAgents: 2,
-            timestamp: Date.now(),
-        };
-        bus.on("provider:degraded", handler);
-        bus.emit("provider:degraded", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.provider).toBe("anthropic");
-        expect(received.failingAgents).toBe(2);
-    });
-    it("provider:recovered delivers provider, timestamp", () => {
-        const bus = new TypedEventBus();
-        const handler = vi.fn();
-        const payload = {
-            provider: "anthropic",
-            timestamp: Date.now(),
-        };
-        bus.on("provider:recovered", handler);
-        bus.emit("provider:recovered", payload);
-        expect(handler).toHaveBeenCalledWith(payload);
-        const received = handler.mock.calls[0][0];
-        expect(received.provider).toBe("anthropic");
-    });
-});

package/node_modules/@comis/core/dist/event-bus/events-channel.test.d.ts

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