comisai 1.0.10 → 1.0.12

package/node_modules/@comis/core/dist/domain/session-key.test.js

@@ -1,291 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseSessionKey, formatSessionKey, parseFormattedSessionKey } from "./session-key.js";
-function validKey(overrides = {}) {
-    return {
-        userId: "user-42",
-        channelId: "general",
-        ...overrides,
-    };
-}
-describe("SessionKey", () => {
-    describe("valid data", () => {
-        it("parses a minimal valid key", () => {
-            const result = parseSessionKey(validKey());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.userId).toBe("user-42");
-                expect(result.value.channelId).toBe("general");
-            }
-        });
-        it("applies default tenantId", () => {
-            const result = parseSessionKey(validKey());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("default");
-            }
-        });
-        it("accepts explicit tenantId", () => {
-            const result = parseSessionKey(validKey({ tenantId: "acme" }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.tenantId).toBe("acme");
-            }
-        });
-        it("accepts optional peerId", () => {
-            const result = parseSessionKey(validKey({ peerId: "peer-99" }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.peerId).toBe("peer-99");
-            }
-        });
-        it("accepts optional guildId", () => {
-            const result = parseSessionKey(validKey({ guildId: "guild-7" }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.guildId).toBe("guild-7");
-            }
-        });
-        it("allows omitting optional fields (peerId, guildId)", () => {
-            const result = parseSessionKey(validKey());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.peerId).toBeUndefined();
-                expect(result.value.guildId).toBeUndefined();
-            }
-        });
-        it("accepts optional agentId", () => {
-            const result = parseSessionKey(validKey({ agentId: "dash" }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.agentId).toBe("dash");
-            }
-        });
-        it("accepts optional threadId", () => {
-            const result = parseSessionKey(validKey({ threadId: "t-123" }));
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.threadId).toBe("t-123");
-            }
-        });
-    });
-    describe("invalid data", () => {
-        it("rejects missing required fields", () => {
-            const result = parseSessionKey({});
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                const paths = result.error.issues.map((i) => i.path[0]);
-                expect(paths).toContain("userId");
-                expect(paths).toContain("channelId");
-            }
-        });
-        it("rejects empty userId", () => {
-            const result = parseSessionKey(validKey({ userId: "" }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects empty channelId", () => {
-            const result = parseSessionKey(validKey({ channelId: "" }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects empty tenantId", () => {
-            const result = parseSessionKey(validKey({ tenantId: "" }));
-            expect(result.ok).toBe(false);
-        });
-        it("strips extra/unknown fields", () => {
-            const result = parseSessionKey(validKey({ extra: "data" }));
-            expect(result.ok).toBe(false);
-        });
-        it("rejects non-object input", () => {
-            const result = parseSessionKey("not-an-object");
-            expect(result.ok).toBe(false);
-        });
-        it("rejects null input", () => {
-            const result = parseSessionKey(null);
-            expect(result.ok).toBe(false);
-        });
-        it("returns descriptive ZodError issues", () => {
-            const result = parseSessionKey({ userId: 123 });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.issues.length).toBeGreaterThan(0);
-                for (const issue of result.error.issues) {
-                    expect(issue.message).toBeTruthy();
-                }
-            }
-        });
-    });
-    describe("formatSessionKey", () => {
-        it("formats basic key", () => {
-            const key = {
-                tenantId: "default",
-                userId: "user-42",
-                channelId: "general",
-            };
-            expect(formatSessionKey(key)).toBe("default:user-42:general");
-        });
-        it("includes peerId when present", () => {
-            const key = {
-                tenantId: "default",
-                userId: "user-42",
-                channelId: "general",
-                peerId: "peer-99",
-            };
-            expect(formatSessionKey(key)).toBe("default:user-42:general:peer:peer-99");
-        });
-        it("includes guildId when present", () => {
-            const key = {
-                tenantId: "default",
-                userId: "user-42",
-                channelId: "general",
-                guildId: "guild-7",
-            };
-            expect(formatSessionKey(key)).toBe("default:user-42:general:guild:guild-7");
-        });
-        it("includes both peerId and guildId when present", () => {
-            const key = {
-                tenantId: "acme",
-                userId: "user-1",
-                channelId: "ch-1",
-                peerId: "p-1",
-                guildId: "g-1",
-            };
-            expect(formatSessionKey(key)).toBe("acme:user-1:ch-1:peer:p-1:guild:g-1");
-        });
-        it("uses custom tenantId", () => {
-            const key = {
-                tenantId: "acme-corp",
-                userId: "admin",
-                channelId: "ops",
-            };
-            expect(formatSessionKey(key)).toBe("acme-corp:admin:ops");
-        });
-        it("prepends agent prefix when agentId is set", () => {
-            const key = {
-                tenantId: "default",
-                userId: "user-42",
-                channelId: "general",
-                agentId: "myAgent",
-            };
-            expect(formatSessionKey(key)).toBe("agent:myAgent:default:user-42:general");
-        });
-        it("appends thread suffix when threadId is set", () => {
-            const key = {
-                tenantId: "default",
-                userId: "user-42",
-                channelId: "general",
-                threadId: "t123",
-            };
-            expect(formatSessionKey(key)).toBe("default:user-42:general:thread:t123");
-        });
-        it("includes both agentId and threadId", () => {
-            const key = {
-                tenantId: "default",
-                userId: "u1",
-                channelId: "c1",
-                peerId: "p1",
-                agentId: "dash",
-                threadId: "th-7",
-            };
-            expect(formatSessionKey(key)).toBe("agent:dash:default:u1:c1:peer:p1:thread:th-7");
-        });
-        it("produces identical output without agentId/threadId", () => {
-            const key = {
-                tenantId: "default",
-                userId: "user-42",
-                channelId: "general",
-                peerId: "peer-99",
-                guildId: "guild-7",
-            };
-            // Must match the original format exactly
-            expect(formatSessionKey(key)).toBe("default:user-42:general:peer:peer-99:guild:guild-7");
-        });
-    });
-    describe("parseFormattedSessionKey", () => {
-        it("parses basic 3-part key", () => {
-            const key = parseFormattedSessionKey("default:user-1:chan-1");
-            expect(key).toEqual({ tenantId: "default", userId: "user-1", channelId: "chan-1" });
-        });
-        it("parses key with peer segment", () => {
-            const key = parseFormattedSessionKey("default:user-1:chan-1:peer:peer-1");
-            expect(key).toEqual({ tenantId: "default", userId: "user-1", channelId: "chan-1", peerId: "peer-1" });
-        });
-        it("parses key with guild segment", () => {
-            const key = parseFormattedSessionKey("default:user-1:chan-1:guild:guild-1");
-            expect(key).toEqual({ tenantId: "default", userId: "user-1", channelId: "chan-1", guildId: "guild-1" });
-        });
-        it("parses key with both peer and guild", () => {
-            const key = parseFormattedSessionKey("default:user-1:chan-1:peer:peer-1:guild:guild-1");
-            expect(key).toEqual({
-                tenantId: "default", userId: "user-1", channelId: "chan-1",
-                peerId: "peer-1", guildId: "guild-1",
-            });
-        });
-        it("roundtrips with formatSessionKey", () => {
-            const original = { tenantId: "t", userId: "u", channelId: "c", peerId: "p", guildId: "g" };
-            const formatted = formatSessionKey(original);
-            const parsed = parseFormattedSessionKey(formatted);
-            expect(parsed).toEqual(original);
-        });
-        it("returns undefined for invalid format (fewer than 3 parts)", () => {
-            expect(parseFormattedSessionKey("only:two")).toBeUndefined();
-            expect(parseFormattedSessionKey("one")).toBeUndefined();
-            expect(parseFormattedSessionKey("")).toBeUndefined();
-        });
-        it("parses agent-prefixed key", () => {
-            const key = parseFormattedSessionKey("agent:dash:default:user-1:chan-1");
-            expect(key).toEqual({
-                tenantId: "default",
-                userId: "user-1",
-                channelId: "chan-1",
-                agentId: "dash",
-            });
-        });
-        it("parses thread-suffixed key", () => {
-            const key = parseFormattedSessionKey("default:user-1:chan-1:thread:t-42");
-            expect(key).toEqual({
-                tenantId: "default",
-                userId: "user-1",
-                channelId: "chan-1",
-                threadId: "t-42",
-            });
-        });
-        it("parses key with agent prefix, peer, guild, and thread", () => {
-            const key = parseFormattedSessionKey("agent:coder:acme:u1:c1:peer:p1:guild:g1:thread:th7");
-            expect(key).toEqual({
-                tenantId: "acme",
-                userId: "u1",
-                channelId: "c1",
-                peerId: "p1",
-                guildId: "g1",
-                agentId: "coder",
-                threadId: "th7",
-            });
-        });
-        it("roundtrips with new fields (agentId + threadId)", () => {
-            const original = {
-                tenantId: "t",
-                userId: "u",
-                channelId: "c",
-                peerId: "p",
-                guildId: "g",
-                agentId: "bot",
-                threadId: "th",
-            };
-            const formatted = formatSessionKey(original);
-            const parsed = parseFormattedSessionKey(formatted);
-            expect(parsed).toEqual(original);
-        });
-        it("still handles old format without agent/thread (regression)", () => {
-            // Old format keys must parse identically to original behavior
-            const key = parseFormattedSessionKey("default:user-1:chan-1:peer:p1:guild:g1");
-            expect(key).toEqual({
-                tenantId: "default",
-                userId: "user-1",
-                channelId: "chan-1",
-                peerId: "p1",
-                guildId: "g1",
-            });
-            expect(key.agentId).toBeUndefined();
-            expect(key.threadId).toBeUndefined();
-        });
-    });
-});

package/node_modules/@comis/core/dist/domain/subagent-context-config.test.d.ts

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

package/node_modules/@comis/core/dist/domain/subagent-context-config.test.js

@@ -1,131 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { SubagentContextConfigSchema } from "./subagent-context-config.js";
-// ---------------------------------------------------------------------------
-// SubagentContextConfigSchema
-// ---------------------------------------------------------------------------
-describe("SubagentContextConfigSchema", () => {
-    it("produces valid defaults from empty object", () => {
-        const result = SubagentContextConfigSchema.parse({});
-        expect(result).toEqual({
-            maxSpawnDepth: 3,
-            maxChildrenPerAgent: 5,
-            maxResultTokens: 4_000,
-            resultRetentionMs: 86_400_000,
-            condensationStrategy: "auto",
-            includeParentHistory: "none",
-            objectiveReinforcement: true,
-            artifactPassthrough: true,
-            autoCompactThreshold: 0.95,
-            errorPreservation: true,
-            narrativeCasting: true,
-            resultTagPrefix: "Subagent Result",
-            parentSummaryMaxTokens: 1_000,
-            maxQueuedPerAgent: 10,
-            queueTimeoutMs: 120_000,
-            maxRunTimeoutMs: 600_000,
-            perStepTimeoutMs: 60_000,
-        });
-        // condensationModel is optional with no default -- should NOT be present
-        expect("condensationModel" in result).toBe(false);
-    });
-    it("accepts full override", () => {
-        const result = SubagentContextConfigSchema.parse({
-            maxSpawnDepth: 5,
-            maxChildrenPerAgent: 10,
-            maxResultTokens: 8_000,
-            resultRetentionMs: 172_800_000,
-            condensationStrategy: "always",
-            includeParentHistory: "summary",
-            objectiveReinforcement: false,
-            artifactPassthrough: false,
-            autoCompactThreshold: 0.8,
-            errorPreservation: false,
-            narrativeCasting: false,
-            resultTagPrefix: "Custom Tag",
-            parentSummaryMaxTokens: 2_000,
-            condensationModel: "groq:llama-3.3-70b-versatile",
-            maxQueuedPerAgent: 20,
-            queueTimeoutMs: 60_000,
-            maxRunTimeoutMs: 300_000,
-            perStepTimeoutMs: 30_000,
-        });
-        expect(result.maxSpawnDepth).toBe(5);
-        expect(result.maxChildrenPerAgent).toBe(10);
-        expect(result.maxResultTokens).toBe(8_000);
-        expect(result.resultRetentionMs).toBe(172_800_000);
-        expect(result.condensationStrategy).toBe("always");
-        expect(result.includeParentHistory).toBe("summary");
-        expect(result.objectiveReinforcement).toBe(false);
-        expect(result.artifactPassthrough).toBe(false);
-        expect(result.autoCompactThreshold).toBe(0.8);
-        expect(result.errorPreservation).toBe(false);
-        expect(result.narrativeCasting).toBe(false);
-        expect(result.resultTagPrefix).toBe("Custom Tag");
-        expect(result.parentSummaryMaxTokens).toBe(2_000);
-        expect(result.condensationModel).toBe("groq:llama-3.3-70b-versatile");
-        expect(result.maxQueuedPerAgent).toBe(20);
-        expect(result.queueTimeoutMs).toBe(60_000);
-        expect(result.maxRunTimeoutMs).toBe(300_000);
-        expect(result.perStepTimeoutMs).toBe(30_000);
-    });
-    it("accepts condensationModel override", () => {
-        const result = SubagentContextConfigSchema.parse({
-            condensationModel: "anthropic:claude-haiku-4-20250514",
-        });
-        expect(result.condensationModel).toBe("anthropic:claude-haiku-4-20250514");
-    });
-    it("rejects unknown keys (strictObject enforcement)", () => {
-        const result = SubagentContextConfigSchema.safeParse({ unknownField: true });
-        expect(result.success).toBe(false);
-    });
-    it("rejects maxSpawnDepth below 1", () => {
-        const result = SubagentContextConfigSchema.safeParse({ maxSpawnDepth: 0 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects maxSpawnDepth above 10", () => {
-        const result = SubagentContextConfigSchema.safeParse({ maxSpawnDepth: 11 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects autoCompactThreshold below 0.5", () => {
-        const result = SubagentContextConfigSchema.safeParse({ autoCompactThreshold: 0.4 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects invalid condensationStrategy", () => {
-        const result = SubagentContextConfigSchema.safeParse({ condensationStrategy: "manual" });
-        expect(result.success).toBe(false);
-    });
-    it("maxQueuedPerAgent defaults to 10", () => {
-        const result = SubagentContextConfigSchema.parse({});
-        expect(result.maxQueuedPerAgent).toBe(10);
-    });
-    it("queueTimeoutMs defaults to 120000", () => {
-        const result = SubagentContextConfigSchema.parse({});
-        expect(result.queueTimeoutMs).toBe(120_000);
-    });
-    it("maxQueuedPerAgent: 0 is valid (disables queuing)", () => {
-        const result = SubagentContextConfigSchema.safeParse({ maxQueuedPerAgent: 0 });
-        expect(result.success).toBe(true);
-        if (result.success)
-            expect(result.data.maxQueuedPerAgent).toBe(0);
-    });
-    it("rejects maxQueuedPerAgent above 50", () => {
-        const result = SubagentContextConfigSchema.safeParse({ maxQueuedPerAgent: 51 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects queueTimeoutMs below 1000", () => {
-        const result = SubagentContextConfigSchema.safeParse({ queueTimeoutMs: 999 });
-        expect(result.success).toBe(false);
-    });
-    it("rejects queueTimeoutMs above 600000", () => {
-        const result = SubagentContextConfigSchema.safeParse({ queueTimeoutMs: 600_001 });
-        expect(result.success).toBe(false);
-    });
-    it("maxRunTimeoutMs defaults to 600000", () => {
-        const result = SubagentContextConfigSchema.parse({});
-        expect(result.maxRunTimeoutMs).toBe(600_000);
-    });
-    it("perStepTimeoutMs defaults to 60000", () => {
-        const result = SubagentContextConfigSchema.parse({});
-        expect(result.perStepTimeoutMs).toBe(60_000);
-    });
-});

package/node_modules/@comis/core/dist/domain/subagent-context-types.test.d.ts

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

package/node_modules/@comis/core/dist/domain/subagent-context-types.test.js

@@ -1,182 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SubagentResultSchema, SubagentEndReasonSchema, parseSubagentResult, } from "./subagent-context-types.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function validResult(overrides = {}) {
-    return {
-        taskComplete: true,
-        summary: "Successfully analyzed the codebase structure.",
-        conclusions: ["The architecture follows hexagonal patterns"],
-        ...overrides,
-    };
-}
-// ---------------------------------------------------------------------------
-// SubagentResultSchema
-// ---------------------------------------------------------------------------
-describe("SubagentResultSchema", () => {
-    describe("valid data", () => {
-        it("accepts valid minimal result", () => {
-            const result = SubagentResultSchema.safeParse(validResult());
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.taskComplete).toBe(true);
-                expect(result.data.summary).toBe("Successfully analyzed the codebase structure.");
-                expect(result.data.conclusions).toEqual(["The architecture follows hexagonal patterns"]);
-            }
-        });
-        it("accepts valid full result", () => {
-            const result = SubagentResultSchema.safeParse(validResult({
-                filePaths: ["/src/index.ts", "/src/types.ts"],
-                actionableItems: ["Review the port interfaces"],
-                errors: ["Minor: unused import in file.ts"],
-                keyData: { linesOfCode: 1500, coverage: 0.85 },
-                confidence: 0.92,
-            }));
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.filePaths).toEqual(["/src/index.ts", "/src/types.ts"]);
-                expect(result.data.actionableItems).toEqual(["Review the port interfaces"]);
-                expect(result.data.errors).toEqual(["Minor: unused import in file.ts"]);
-                expect(result.data.keyData).toEqual({ linesOfCode: 1500, coverage: 0.85 });
-                expect(result.data.confidence).toBe(0.92);
-            }
-        });
-    });
-    describe("invalid data", () => {
-        it("rejects missing required field taskComplete", () => {
-            const { taskComplete: _, ...rest } = validResult();
-            const result = SubagentResultSchema.safeParse(rest);
-            expect(result.success).toBe(false);
-        });
-        it("rejects missing required field summary", () => {
-            const { summary: _, ...rest } = validResult();
-            const result = SubagentResultSchema.safeParse(rest);
-            expect(result.success).toBe(false);
-        });
-        it("rejects missing required field conclusions", () => {
-            const { conclusions: _, ...rest } = validResult();
-            const result = SubagentResultSchema.safeParse(rest);
-            expect(result.success).toBe(false);
-        });
-        it("rejects empty summary", () => {
-            const result = SubagentResultSchema.safeParse(validResult({ summary: "" }));
-            expect(result.success).toBe(false);
-        });
-        it("rejects empty conclusions array", () => {
-            const result = SubagentResultSchema.safeParse(validResult({ conclusions: [] }));
-            expect(result.success).toBe(false);
-        });
-        it("rejects confidence outside 0-1 range", () => {
-            const tooHigh = SubagentResultSchema.safeParse(validResult({ confidence: 1.5 }));
-            expect(tooHigh.success).toBe(false);
-            const tooLow = SubagentResultSchema.safeParse(validResult({ confidence: -0.1 }));
-            expect(tooLow.success).toBe(false);
-        });
-        it("rejects unknown keys", () => {
-            const result = SubagentResultSchema.safeParse(validResult({ unknownField: "surprise" }));
-            expect(result.success).toBe(false);
-        });
-    });
-    describe("parseSubagentResult", () => {
-        it("returns ok() on valid input", () => {
-            const result = parseSubagentResult(validResult());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.taskComplete).toBe(true);
-                expect(result.value.summary).toBe("Successfully analyzed the codebase structure.");
-            }
-        });
-        it("returns err() on invalid input", () => {
-            const result = parseSubagentResult({ taskComplete: "not a boolean" });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.issues.length).toBeGreaterThan(0);
-            }
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// SubagentEndReasonSchema
-// ---------------------------------------------------------------------------
-describe("SubagentEndReasonSchema", () => {
-    it("accepts valid reasons", () => {
-        const reasons = ["completed", "failed", "killed", "swept"];
-        for (const reason of reasons) {
-            const result = SubagentEndReasonSchema.safeParse(reason);
-            expect(result.success).toBe(true);
-        }
-    });
-    it("rejects invalid reason", () => {
-        const result = SubagentEndReasonSchema.safeParse("cancelled");
-        expect(result.success).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// Type Assertion Tests (compile-time only)
-// ---------------------------------------------------------------------------
-describe("Type assertions", () => {
-    it("SpawnPacket literal satisfies the interface", () => {
-        const packet = {
-            task: "analyze codebase",
-            artifactRefs: ["/src/index.ts"],
-            domainKnowledge: ["hexagonal architecture"],
-            toolGroups: ["coding"],
-            objective: "Understand the project structure",
-            workspaceDir: "/workspace",
-            depth: 1,
-            maxDepth: 3,
-        };
-        // Compile-time check: if this file compiles, the type assertion holds
-        expect(packet).toBeTruthy();
-    });
-    it("SpawnPacket accepts optional parentSummary", () => {
-        const packet = {
-            task: "analyze codebase",
-            artifactRefs: [],
-            domainKnowledge: [],
-            toolGroups: [],
-            objective: "Understand the project structure",
-            parentSummary: "Parent was working on auth module",
-            workspaceDir: "/workspace",
-            depth: 0,
-            maxDepth: 3,
-        };
-        expect(packet).toBeTruthy();
-        expect(packet.parentSummary).toBe("Parent was working on auth module");
-    });
-    it("SpawnPacket accepts optional agentWorkspaces", () => {
-        const packet = {
-            task: "update agent configs",
-            artifactRefs: [],
-            domainKnowledge: [],
-            toolGroups: [],
-            objective: "Modify workspace files for all agents",
-            workspaceDir: "/workspace",
-            depth: 1,
-            maxDepth: 3,
-            agentWorkspaces: {
-                "default": "/home/user/.comis/workspace",
-                "technical-analyst": "/home/user/.comis/workspace-technical-analyst",
-            },
-        };
-        expect(packet).toBeTruthy();
-        expect(packet.agentWorkspaces).toBeDefined();
-        expect(Object.keys(packet.agentWorkspaces)).toHaveLength(2);
-    });
-    it("CondensedResult literal satisfies the interface", () => {
-        const condensed = {
-            level: 2,
-            result: {
-                taskComplete: true,
-                summary: "Completed analysis",
-                conclusions: ["All good"],
-            },
-            originalTokens: 5000,
-            condensedTokens: 2000,
-            compressionRatio: 0.4,
-            diskPath: "/tmp/result-001.json",
-        };
-        expect(condensed).toBeTruthy();
-    });
-});

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

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