@bryan-thompson/inspector-assessment-cli 1.25.0 → 1.25.4

package/build/__tests__/assess-full.test.js

@@ -0,0 +1,345 @@
+/**
+ * Assess-Full CLI Unit Tests
+ *
+ * Tests for CLI argument parsing concepts, config building, and validation logic.
+ * These tests focus on pure logic that can be tested without mocking complex
+ * external dependencies. For integration testing of the full CLI, use the
+ * actual CLI binary.
+ */
+import { describe, it, expect } from "@jest/globals";
+import * as path from "path";
+/**
+ * Pure function tests - these test logic concepts used in the CLI
+ * without needing to import the actual module (which has side effects)
+ */
+describe("CLI Argument Parsing Concepts", () => {
+    describe("Profile Flag Parsing", () => {
+        const VALID_PROFILES = ["quick", "security", "compliance", "full"];
+        function parseProfile(args) {
+            const profileIndex = args.indexOf("--profile");
+            if (profileIndex === -1) {
+                return {}; // No profile specified
+            }
+            const profileValue = args[profileIndex + 1];
+            if (!profileValue || profileValue.startsWith("--")) {
+                return { error: "Missing profile value" };
+            }
+            if (!VALID_PROFILES.includes(profileValue)) {
+                return { error: `Invalid profile: ${profileValue}` };
+            }
+            return { profile: profileValue };
+        }
+        it("should parse valid profile flags", () => {
+            expect(parseProfile(["--profile", "quick"])).toEqual({
+                profile: "quick",
+            });
+            expect(parseProfile(["--profile", "security"])).toEqual({
+                profile: "security",
+            });
+            expect(parseProfile(["--profile", "compliance"])).toEqual({
+                profile: "compliance",
+            });
+            expect(parseProfile(["--profile", "full"])).toEqual({ profile: "full" });
+        });
+        it("should handle missing profile value", () => {
+            expect(parseProfile(["--profile"])).toEqual({
+                error: "Missing profile value",
+            });
+            expect(parseProfile(["--profile", "--other"])).toEqual({
+                error: "Missing profile value",
+            });
+        });
+        it("should reject invalid profile names", () => {
+            expect(parseProfile(["--profile", "invalid"])).toEqual({
+                error: "Invalid profile: invalid",
+            });
+            expect(parseProfile(["--profile", "QUICK"])).toEqual({
+                error: "Invalid profile: QUICK",
+            });
+        });
+        it("should return empty when no profile specified", () => {
+            expect(parseProfile([])).toEqual({});
+            expect(parseProfile(["--server", "test"])).toEqual({});
+        });
+    });
+    describe("Module List Parsing", () => {
+        function parseModules(input) {
+            return input
+                .split(",")
+                .map((n) => n.trim())
+                .filter(Boolean);
+        }
+        it("should parse comma-separated modules", () => {
+            expect(parseModules("security,functionality")).toEqual([
+                "security",
+                "functionality",
+            ]);
+        });
+        it("should trim whitespace", () => {
+            expect(parseModules("security , functionality , temporal")).toEqual([
+                "security",
+                "functionality",
+                "temporal",
+            ]);
+        });
+        it("should filter empty values", () => {
+            expect(parseModules("security,,functionality")).toEqual([
+                "security",
+                "functionality",
+            ]);
+        });
+        it("should handle single module", () => {
+            expect(parseModules("security")).toEqual(["security"]);
+        });
+        it("should handle empty input", () => {
+            expect(parseModules("")).toEqual([]);
+        });
+    });
+    describe("Output Format Validation", () => {
+        const VALID_FORMATS = ["json", "markdown", "html"];
+        function validateFormat(format) {
+            return VALID_FORMATS.includes(format);
+        }
+        it("should accept valid formats", () => {
+            expect(validateFormat("json")).toBe(true);
+            expect(validateFormat("markdown")).toBe(true);
+            expect(validateFormat("html")).toBe(true);
+        });
+        it("should reject invalid formats", () => {
+            expect(validateFormat("xml")).toBe(false);
+            expect(validateFormat("JSON")).toBe(false);
+            expect(validateFormat("pdf")).toBe(false);
+        });
+    });
+});
+describe("Config File Handling", () => {
+    describe("Config Parsing", () => {
+        function validateConfig(config) {
+            const transport = config.transport || "stdio";
+            if (transport === "stdio") {
+                if (!config.command) {
+                    return { valid: false, error: "STDIO transport requires command" };
+                }
+                return { valid: true };
+            }
+            if (transport === "http" || transport === "sse") {
+                if (!config.url) {
+                    return {
+                        valid: false,
+                        error: `${transport.toUpperCase()} transport requires url`,
+                    };
+                }
+                return { valid: true };
+            }
+            return { valid: false, error: `Unknown transport: ${transport}` };
+        }
+        it("should validate STDIO config", () => {
+            expect(validateConfig({
+                transport: "stdio",
+                command: "python",
+                args: ["-m", "server"],
+            })).toEqual({ valid: true });
+        });
+        it("should require command for STDIO", () => {
+            expect(validateConfig({ transport: "stdio" })).toEqual({
+                valid: false,
+                error: "STDIO transport requires command",
+            });
+        });
+        it("should validate HTTP config", () => {
+            expect(validateConfig({ transport: "http", url: "http://localhost:3000/mcp" })).toEqual({ valid: true });
+        });
+        it("should require url for HTTP", () => {
+            expect(validateConfig({ transport: "http" })).toEqual({
+                valid: false,
+                error: "HTTP transport requires url",
+            });
+        });
+        it("should validate SSE config", () => {
+            expect(validateConfig({ transport: "sse", url: "http://localhost:3000/sse" })).toEqual({ valid: true });
+        });
+        it("should require url for SSE", () => {
+            expect(validateConfig({ transport: "sse" })).toEqual({
+                valid: false,
+                error: "SSE transport requires url",
+            });
+        });
+        it("should default to STDIO when transport not specified", () => {
+            expect(validateConfig({ command: "node" })).toEqual({ valid: true });
+        });
+    });
+    describe("Config File Reading", () => {
+        it("should detect JSON file by extension", () => {
+            const filePath = "/tmp/config.json";
+            expect(path.extname(filePath)).toBe(".json");
+        });
+        it("should handle paths with multiple dots", () => {
+            const filePath = "/tmp/my.server.config.json";
+            expect(path.extname(filePath)).toBe(".json");
+        });
+    });
+});
+describe("Exit Code Logic", () => {
+    function determineExitCode(result) {
+        if (result.overallStatus === "FAIL")
+            return 1;
+        if (result.security?.vulnerabilities &&
+            result.security.vulnerabilities.length > 0) {
+            return 1;
+        }
+        return 0;
+    }
+    it("should return 0 for PASS with no vulnerabilities", () => {
+        expect(determineExitCode({ overallStatus: "PASS" })).toBe(0);
+    });
+    it("should return 1 for FAIL status", () => {
+        expect(determineExitCode({ overallStatus: "FAIL" })).toBe(1);
+    });
+    it("should return 1 when vulnerabilities exist", () => {
+        expect(determineExitCode({
+            overallStatus: "PASS",
+            security: { vulnerabilities: [{ type: "injection" }] },
+        })).toBe(1);
+    });
+    it("should return 0 for PASS with empty vulnerabilities", () => {
+        expect(determineExitCode({
+            overallStatus: "PASS",
+            security: { vulnerabilities: [] },
+        })).toBe(0);
+    });
+});
+describe("State Management Concepts", () => {
+    describe("Resume Flag Parsing", () => {
+        function getResumeMode(args) {
+            if (args.includes("--no-resume"))
+                return "no-resume";
+            if (args.includes("--resume"))
+                return "resume";
+            return "default";
+        }
+        it("should detect --resume flag", () => {
+            expect(getResumeMode(["--resume"])).toBe("resume");
+            expect(getResumeMode(["--server", "test", "--resume"])).toBe("resume");
+        });
+        it("should detect --no-resume flag", () => {
+            expect(getResumeMode(["--no-resume"])).toBe("no-resume");
+        });
+        it("should return default when neither specified", () => {
+            expect(getResumeMode([])).toBe("default");
+            expect(getResumeMode(["--server", "test"])).toBe("default");
+        });
+        it("should handle --no-resume even when --resume also present", () => {
+            // --no-resume takes precedence
+            expect(getResumeMode(["--resume", "--no-resume"])).toBe("no-resume");
+        });
+    });
+    describe("State File Path Generation", () => {
+        function getStateFilePath(serverName, outputDir) {
+            const dir = outputDir || "/tmp";
+            return path.join(dir, `.${serverName}-assessment-state.json`);
+        }
+        it("should generate state file path with server name", () => {
+            expect(getStateFilePath("test-server")).toBe("/tmp/.test-server-assessment-state.json");
+        });
+        it("should use custom output directory", () => {
+            expect(getStateFilePath("test-server", "/home/user/results")).toBe("/home/user/results/.test-server-assessment-state.json");
+        });
+        it("should handle server names with special characters", () => {
+            expect(getStateFilePath("my-mcp-server")).toBe("/tmp/.my-mcp-server-assessment-state.json");
+        });
+    });
+});
+describe("Output Path Generation", () => {
+    describe("Default Output Paths", () => {
+        function getDefaultOutputPath(serverName, format) {
+            const ext = format === "markdown" ? ".md" : `.${format}`;
+            return `/tmp/inspector-assessment-${serverName}${ext}`;
+        }
+        it("should generate JSON output path", () => {
+            expect(getDefaultOutputPath("my-server", "json")).toBe("/tmp/inspector-assessment-my-server.json");
+        });
+        it("should generate Markdown output path", () => {
+            expect(getDefaultOutputPath("my-server", "markdown")).toBe("/tmp/inspector-assessment-my-server.md");
+        });
+        it("should generate HTML output path", () => {
+            expect(getDefaultOutputPath("my-server", "html")).toBe("/tmp/inspector-assessment-my-server.html");
+        });
+    });
+    describe("Custom Output Paths", () => {
+        function resolveOutputPath(specified, serverName, format) {
+            if (specified) {
+                // If directory, append filename
+                if (!path.extname(specified)) {
+                    const ext = format === "markdown" ? ".md" : `.${format}`;
+                    return path.join(specified, `inspector-assessment-${serverName}${ext}`);
+                }
+                return specified;
+            }
+            const ext = format === "markdown" ? ".md" : `.${format}`;
+            return `/tmp/inspector-assessment-${serverName}${ext}`;
+        }
+        it("should use specified path directly if it has extension", () => {
+            expect(resolveOutputPath("/home/user/results.json", "server", "json")).toBe("/home/user/results.json");
+        });
+        it("should append filename if path is a directory", () => {
+            expect(resolveOutputPath("/home/user/results", "server", "json")).toBe("/home/user/results/inspector-assessment-server.json");
+        });
+        it("should use default when not specified", () => {
+            expect(resolveOutputPath(undefined, "server", "json")).toBe("/tmp/inspector-assessment-server.json");
+        });
+    });
+});
+describe("Boolean Flag Parsing", () => {
+    function parseBooleanFlags(args) {
+        const flags = {
+            verbose: false,
+            silent: false,
+            claudeEnabled: false,
+            includePolicy: false,
+            preflight: false,
+        };
+        if (args.includes("--verbose") || args.includes("-v"))
+            flags.verbose = true;
+        if (args.includes("--silent") || args.includes("-s"))
+            flags.silent = true;
+        if (args.includes("--claude-enabled"))
+            flags.claudeEnabled = true;
+        if (args.includes("--include-policy"))
+            flags.includePolicy = true;
+        if (args.includes("--preflight"))
+            flags.preflight = true;
+        return flags;
+    }
+    it("should parse verbose flag", () => {
+        expect(parseBooleanFlags(["--verbose"]).verbose).toBe(true);
+        expect(parseBooleanFlags(["-v"]).verbose).toBe(true);
+    });
+    it("should parse silent flag", () => {
+        expect(parseBooleanFlags(["--silent"]).silent).toBe(true);
+        expect(parseBooleanFlags(["-s"]).silent).toBe(true);
+    });
+    it("should parse claude-enabled flag", () => {
+        expect(parseBooleanFlags(["--claude-enabled"]).claudeEnabled).toBe(true);
+    });
+    it("should parse include-policy flag", () => {
+        expect(parseBooleanFlags(["--include-policy"]).includePolicy).toBe(true);
+    });
+    it("should parse preflight flag", () => {
+        expect(parseBooleanFlags(["--preflight"]).preflight).toBe(true);
+    });
+    it("should handle multiple flags", () => {
+        const flags = parseBooleanFlags([
+            "--verbose",
+            "--include-policy",
+            "--preflight",
+        ]);
+        expect(flags.verbose).toBe(true);
+        expect(flags.includePolicy).toBe(true);
+        expect(flags.preflight).toBe(true);
+        expect(flags.silent).toBe(false);
+    });
+    it("should return all false when no flags", () => {
+        const flags = parseBooleanFlags([]);
+        expect(Object.values(flags).every((v) => v === false)).toBe(true);
+    });
+});

package/build/__tests__/jsonl-events.test.js

@@ -0,0 +1,358 @@
+/**
+ * JSONL Events Module Unit Tests
+ *
+ * Tests for JSONL event emission functions used for real-time monitoring.
+ */
+import { jest, describe, it, expect, beforeEach, afterEach, } from "@jest/globals";
+import { emitJSONL, emitServerConnected, emitToolDiscovered, emitToolsDiscoveryComplete, emitAssessmentComplete, emitTestBatch, emitVulnerabilityFound, emitAnnotationMissing, emitAnnotationMisaligned, emitAnnotationReviewRecommended, emitAnnotationAligned, emitModulesConfigured, extractToolParams, } from "../lib/jsonl-events.js";
+describe("JSONL Event Emission", () => {
+    let consoleErrorSpy;
+    let emittedEvents;
+    beforeEach(() => {
+        emittedEvents = [];
+        consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(((msg) => {
+            try {
+                emittedEvents.push(JSON.parse(msg));
+            }
+            catch {
+                // Not JSON, ignore
+            }
+        }));
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+    });
+    describe("emitJSONL", () => {
+        it("should emit event to stderr as JSON", () => {
+            emitJSONL({ event: "test", data: "value" });
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            expect(emittedEvents[0]).toHaveProperty("event", "test");
+            expect(emittedEvents[0]).toHaveProperty("data", "value");
+        });
+        it("should include version field", () => {
+            emitJSONL({ event: "test" });
+            expect(emittedEvents[0]).toHaveProperty("version");
+        });
+        it("should handle complex nested objects", () => {
+            emitJSONL({
+                event: "complex",
+                nested: { a: 1, b: [2, 3] },
+            });
+            expect(emittedEvents[0]).toHaveProperty("nested.a", 1);
+        });
+    });
+    describe("emitServerConnected", () => {
+        it("should emit server_connected event", () => {
+            emitServerConnected("test-server", "http");
+            expect(emittedEvents[0]).toHaveProperty("event", "server_connected");
+            expect(emittedEvents[0]).toHaveProperty("serverName", "test-server");
+            expect(emittedEvents[0]).toHaveProperty("transport", "http");
+        });
+        it("should handle different transport types", () => {
+            emitServerConnected("server1", "stdio");
+            emitServerConnected("server2", "sse");
+            emitServerConnected("server3", "http");
+            expect(emittedEvents[0]).toHaveProperty("transport", "stdio");
+            expect(emittedEvents[1]).toHaveProperty("transport", "sse");
+            expect(emittedEvents[2]).toHaveProperty("transport", "http");
+        });
+    });
+    describe("emitToolDiscovered", () => {
+        it("should emit tool_discovered event with basic info", () => {
+            const tool = {
+                name: "test_tool",
+                description: "A test tool",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            };
+            emitToolDiscovered(tool);
+            expect(emittedEvents[0]).toHaveProperty("event", "tool_discovered");
+            expect(emittedEvents[0]).toHaveProperty("name", "test_tool");
+            expect(emittedEvents[0]).toHaveProperty("description", "A test tool");
+        });
+        it("should handle tool without description", () => {
+            const tool = {
+                name: "no_desc_tool",
+                inputSchema: { type: "object" },
+            };
+            emitToolDiscovered(tool);
+            expect(emittedEvents[0]).toHaveProperty("name", "no_desc_tool");
+            expect(emittedEvents[0]).toHaveProperty("description", null);
+        });
+        it("should extract parameters from inputSchema", () => {
+            const tool = {
+                name: "param_tool",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Search query" },
+                        limit: { type: "number" },
+                    },
+                    required: ["query"],
+                },
+            };
+            emitToolDiscovered(tool);
+            const params = emittedEvents[0].params;
+            expect(params.length).toBe(2);
+            expect(params.find((p) => p.name === "query")).toMatchObject({
+                name: "query",
+                type: "string",
+                required: true,
+                description: "Search query",
+            });
+            expect(params.find((p) => p.name === "limit")).toMatchObject({
+                name: "limit",
+                type: "number",
+                required: false,
+            });
+        });
+        it("should include annotations when present", () => {
+            const tool = {
+                name: "annotated_tool",
+                inputSchema: { type: "object" },
+                annotations: {
+                    readOnlyHint: true,
+                    destructiveHint: false,
+                    idempotentHint: true,
+                    openWorldHint: false,
+                },
+            };
+            emitToolDiscovered(tool);
+            const annotations = emittedEvents[0].annotations;
+            expect(annotations).not.toBeNull();
+            expect(annotations.readOnlyHint).toBe(true);
+            expect(annotations.destructiveHint).toBe(false);
+        });
+        it("should have null annotations when not present", () => {
+            const tool = {
+                name: "no_annotations",
+                inputSchema: { type: "object" },
+            };
+            emitToolDiscovered(tool);
+            expect(emittedEvents[0].annotations).toBeNull();
+        });
+    });
+    describe("emitToolsDiscoveryComplete", () => {
+        it("should emit tools_discovery_complete with count", () => {
+            emitToolsDiscoveryComplete(15);
+            expect(emittedEvents[0]).toHaveProperty("event", "tools_discovery_complete");
+            expect(emittedEvents[0]).toHaveProperty("count", 15);
+        });
+        it("should handle zero tools", () => {
+            emitToolsDiscoveryComplete(0);
+            expect(emittedEvents[0]).toHaveProperty("count", 0);
+        });
+    });
+    describe("emitAssessmentComplete", () => {
+        it("should emit assessment_complete with all fields", () => {
+            emitAssessmentComplete("PASS", 1500, 120000, "/tmp/results.json");
+            expect(emittedEvents[0]).toHaveProperty("event", "assessment_complete");
+            expect(emittedEvents[0]).toHaveProperty("overallStatus", "PASS");
+            expect(emittedEvents[0]).toHaveProperty("totalTests", 1500);
+            expect(emittedEvents[0]).toHaveProperty("executionTime", 120000);
+            expect(emittedEvents[0]).toHaveProperty("outputPath", "/tmp/results.json");
+        });
+        it("should handle FAIL status", () => {
+            emitAssessmentComplete("FAIL", 200, 60000, "/tmp/fail.json");
+            expect(emittedEvents[0]).toHaveProperty("overallStatus", "FAIL");
+        });
+    });
+    describe("emitTestBatch", () => {
+        it("should emit test_batch with progress info", () => {
+            emitTestBatch("security", 100, 500, 50, 30000);
+            expect(emittedEvents[0]).toHaveProperty("event", "test_batch");
+            expect(emittedEvents[0]).toHaveProperty("module", "security");
+            expect(emittedEvents[0]).toHaveProperty("completed", 100);
+            expect(emittedEvents[0]).toHaveProperty("total", 500);
+            expect(emittedEvents[0]).toHaveProperty("batchSize", 50);
+            expect(emittedEvents[0]).toHaveProperty("elapsed", 30000);
+        });
+        it("should handle final batch", () => {
+            emitTestBatch("functionality", 100, 100, 10, 5000);
+            expect(emittedEvents[0]).toHaveProperty("completed", 100);
+            expect(emittedEvents[0]).toHaveProperty("total", 100);
+        });
+    });
+    describe("emitVulnerabilityFound", () => {
+        it("should emit vulnerability_found with all fields", () => {
+            emitVulnerabilityFound("exec_tool", "Command Injection", "high", "Response executed shell command", "HIGH", true, "; rm -rf /");
+            expect(emittedEvents[0]).toHaveProperty("event", "vulnerability_found");
+            expect(emittedEvents[0]).toHaveProperty("tool", "exec_tool");
+            expect(emittedEvents[0]).toHaveProperty("pattern", "Command Injection");
+            expect(emittedEvents[0]).toHaveProperty("confidence", "high");
+            expect(emittedEvents[0]).toHaveProperty("evidence", "Response executed shell command");
+            expect(emittedEvents[0]).toHaveProperty("riskLevel", "HIGH");
+            expect(emittedEvents[0]).toHaveProperty("requiresReview", true);
+            expect(emittedEvents[0]).toHaveProperty("payload", "; rm -rf /");
+        });
+        it("should omit payload when not provided", () => {
+            emitVulnerabilityFound("tool", "SQLi", "medium", "evidence", "MEDIUM", false);
+            expect(emittedEvents[0]).not.toHaveProperty("payload");
+        });
+        it("should handle different confidence levels", () => {
+            emitVulnerabilityFound("t1", "p1", "high", "e1", "HIGH", true);
+            emitVulnerabilityFound("t2", "p2", "medium", "e2", "MEDIUM", false);
+            emitVulnerabilityFound("t3", "p3", "low", "e3", "LOW", false);
+            expect(emittedEvents[0]).toHaveProperty("confidence", "high");
+            expect(emittedEvents[1]).toHaveProperty("confidence", "medium");
+            expect(emittedEvents[2]).toHaveProperty("confidence", "low");
+        });
+    });
+    describe("emitAnnotationMissing", () => {
+        it("should emit annotation_missing with tool info", () => {
+            const params = [
+                { name: "file", type: "string", required: true },
+            ];
+            emitAnnotationMissing("delete_file", "Delete File", "Deletes a file", params, {
+                expectedReadOnly: false,
+                expectedDestructive: true,
+                reason: "delete operation implies destructive",
+            });
+            expect(emittedEvents[0]).toHaveProperty("event", "annotation_missing");
+            expect(emittedEvents[0]).toHaveProperty("tool", "delete_file");
+            expect(emittedEvents[0]).toHaveProperty("title", "Delete File");
+            expect(emittedEvents[0]).toHaveProperty("description", "Deletes a file");
+            expect(emittedEvents[0]).toHaveProperty("parameters", params);
+            expect(emittedEvents[0]).toHaveProperty("inferredBehavior");
+        });
+        it("should omit optional fields when undefined", () => {
+            emitAnnotationMissing("tool", undefined, undefined, [], {
+                expectedReadOnly: true,
+                expectedDestructive: false,
+                reason: "test",
+            });
+            expect(emittedEvents[0]).not.toHaveProperty("title");
+            expect(emittedEvents[0]).not.toHaveProperty("description");
+        });
+    });
+    describe("emitAnnotationMisaligned", () => {
+        it("should emit annotation_misaligned with all fields", () => {
+            const params = [];
+            emitAnnotationMisaligned("write_tool", "Write Data", "Writes to disk", params, "readOnlyHint", true, false, 0.95, "Tool performs write operations");
+            expect(emittedEvents[0]).toHaveProperty("event", "annotation_misaligned");
+            expect(emittedEvents[0]).toHaveProperty("tool", "write_tool");
+            expect(emittedEvents[0]).toHaveProperty("field", "readOnlyHint");
+            expect(emittedEvents[0]).toHaveProperty("actual", true);
+            expect(emittedEvents[0]).toHaveProperty("expected", false);
+            expect(emittedEvents[0]).toHaveProperty("confidence", 0.95);
+            expect(emittedEvents[0]).toHaveProperty("reason", "Tool performs write operations");
+        });
+        it("should handle undefined actual value", () => {
+            emitAnnotationMisaligned("tool", undefined, undefined, [], "destructiveHint", undefined, true, 0.8, "reason");
+            // JSON.stringify omits undefined values, so the property won't exist
+            expect(emittedEvents[0]).not.toHaveProperty("actual");
+        });
+    });
+    describe("emitAnnotationReviewRecommended", () => {
+        it("should emit annotation_review_recommended with all fields", () => {
+            emitAnnotationReviewRecommended("cache_tool", "Cache Manager", "Manages cache", [], "readOnlyHint", undefined, false, "medium", true, "Cache operations are ambiguous");
+            expect(emittedEvents[0]).toHaveProperty("event", "annotation_review_recommended");
+            expect(emittedEvents[0]).toHaveProperty("tool", "cache_tool");
+            expect(emittedEvents[0]).toHaveProperty("confidence", "medium");
+            expect(emittedEvents[0]).toHaveProperty("isAmbiguous", true);
+        });
+    });
+    describe("emitAnnotationAligned", () => {
+        it("should emit annotation_aligned with annotations", () => {
+            emitAnnotationAligned("read_tool", "high", {
+                readOnlyHint: true,
+                destructiveHint: false,
+            });
+            expect(emittedEvents[0]).toHaveProperty("event", "annotation_aligned");
+            expect(emittedEvents[0]).toHaveProperty("tool", "read_tool");
+            expect(emittedEvents[0]).toHaveProperty("confidence", "high");
+            expect(emittedEvents[0]).toHaveProperty("annotations");
+        });
+    });
+    describe("emitModulesConfigured", () => {
+        it("should emit modules_configured with enabled and skipped", () => {
+            emitModulesConfigured(["security", "functionality"], ["temporal"], "skip-modules");
+            expect(emittedEvents[0]).toHaveProperty("event", "modules_configured");
+            expect(emittedEvents[0]).toHaveProperty("enabled", [
+                "security",
+                "functionality",
+            ]);
+            expect(emittedEvents[0]).toHaveProperty("skipped", ["temporal"]);
+            expect(emittedEvents[0]).toHaveProperty("reason", "skip-modules");
+        });
+        it("should handle only-modules reason", () => {
+            emitModulesConfigured(["security"], [], "only-modules");
+            expect(emittedEvents[0]).toHaveProperty("reason", "only-modules");
+        });
+        it("should handle default reason", () => {
+            emitModulesConfigured(["security", "functionality"], [], "default");
+            expect(emittedEvents[0]).toHaveProperty("reason", "default");
+        });
+    });
+});
+describe("extractToolParams", () => {
+    it("should return empty array for null schema", () => {
+        expect(extractToolParams(null)).toEqual([]);
+    });
+    it("should return empty array for undefined schema", () => {
+        expect(extractToolParams(undefined)).toEqual([]);
+    });
+    it("should return empty array for non-object schema", () => {
+        expect(extractToolParams("string")).toEqual([]);
+    });
+    it("should return empty array for schema without properties", () => {
+        expect(extractToolParams({ type: "object" })).toEqual([]);
+    });
+    it("should extract parameters with all fields", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "User name" },
+                age: { type: "number" },
+            },
+            required: ["name"],
+        };
+        const params = extractToolParams(schema);
+        expect(params.length).toBe(2);
+        const nameParam = params.find((p) => p.name === "name");
+        expect(nameParam).toEqual({
+            name: "name",
+            type: "string",
+            required: true,
+            description: "User name",
+        });
+        const ageParam = params.find((p) => p.name === "age");
+        expect(ageParam).toEqual({
+            name: "age",
+            type: "number",
+            required: false,
+        });
+    });
+    it("should handle schema without required array", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                optional: { type: "string" },
+            },
+        };
+        const params = extractToolParams(schema);
+        expect(params[0].required).toBe(false);
+    });
+    it("should default to 'any' type when not specified", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                unknown: {},
+            },
+        };
+        const params = extractToolParams(schema);
+        expect(params[0].type).toBe("any");
+    });
+    it("should not include description when not present", () => {
+        const schema = {
+            type: "object",
+            properties: {
+                simple: { type: "boolean" },
+            },
+        };
+        const params = extractToolParams(schema);
+        expect(params[0]).not.toHaveProperty("description");
+    });
+});

package/build/__tests__/profiles.test.js

@@ -0,0 +1,301 @@
+/**
+ * Profile Module Unit Tests
+ *
+ * Tests for profile definitions, module resolution, and legacy config mapping.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { jest, describe, it, expect } from "@jest/globals";
+import { ASSESSMENT_PROFILES, PROFILE_METADATA, MODULE_ALIASES, DEPRECATED_MODULES, TIER_1_CORE_SECURITY, TIER_2_COMPLIANCE, TIER_3_CAPABILITY, TIER_4_EXTENDED, ALL_MODULES, resolveModuleNames, getProfileModules, isValidProfileName, getProfileHelpText, mapLegacyConfigToModules, modulesToLegacyConfig, } from "../profiles.js";
+describe("Profile Definitions", () => {
+    describe("Profile Constants", () => {
+        it("should have four profiles defined", () => {
+            const profiles = Object.keys(ASSESSMENT_PROFILES);
+            expect(profiles).toEqual(["quick", "security", "compliance", "full"]);
+        });
+        it("should have metadata for all profiles", () => {
+            const profileNames = Object.keys(ASSESSMENT_PROFILES);
+            const metadataNames = Object.keys(PROFILE_METADATA);
+            expect(metadataNames).toEqual(profileNames);
+        });
+        it("should have correct module counts in metadata", () => {
+            for (const [name, meta] of Object.entries(PROFILE_METADATA)) {
+                const profile = ASSESSMENT_PROFILES[name];
+                expect(meta.moduleCount).toBe(profile.length);
+            }
+        });
+    });
+    describe("Tier Definitions", () => {
+        it("should have Tier 1 core security modules", () => {
+            expect(TIER_1_CORE_SECURITY).toContain("functionality");
+            expect(TIER_1_CORE_SECURITY).toContain("security");
+            expect(TIER_1_CORE_SECURITY).toContain("temporal");
+            expect(TIER_1_CORE_SECURITY).toContain("errorHandling");
+            expect(TIER_1_CORE_SECURITY).toContain("protocolCompliance");
+            expect(TIER_1_CORE_SECURITY).toContain("aupCompliance");
+        });
+        it("should have Tier 2 compliance modules", () => {
+            expect(TIER_2_COMPLIANCE).toContain("toolAnnotations");
+            expect(TIER_2_COMPLIANCE).toContain("prohibitedLibraries");
+            expect(TIER_2_COMPLIANCE).toContain("manifestValidation");
+            expect(TIER_2_COMPLIANCE).toContain("authentication");
+        });
+        it("should have Tier 3 capability modules", () => {
+            expect(TIER_3_CAPABILITY).toContain("resources");
+            expect(TIER_3_CAPABILITY).toContain("prompts");
+            expect(TIER_3_CAPABILITY).toContain("crossCapability");
+        });
+        it("should have Tier 4 extended modules", () => {
+            expect(TIER_4_EXTENDED).toContain("developerExperience");
+            expect(TIER_4_EXTENDED).toContain("portability");
+            expect(TIER_4_EXTENDED).toContain("externalAPIScanner");
+        });
+        it("should combine all tiers in ALL_MODULES", () => {
+            const expectedLength = TIER_1_CORE_SECURITY.length +
+                TIER_2_COMPLIANCE.length +
+                TIER_3_CAPABILITY.length +
+                TIER_4_EXTENDED.length;
+            expect(ALL_MODULES.length).toBe(expectedLength);
+        });
+    });
+    describe("Profile Compositions", () => {
+        it("quick profile should have functionality and security only", () => {
+            expect(ASSESSMENT_PROFILES.quick).toEqual(["functionality", "security"]);
+        });
+        it("security profile should include all Tier 1 modules", () => {
+            for (const module of TIER_1_CORE_SECURITY) {
+                expect(ASSESSMENT_PROFILES.security).toContain(module);
+            }
+        });
+        it("compliance profile should include Tier 1 and Tier 2", () => {
+            for (const module of TIER_1_CORE_SECURITY) {
+                expect(ASSESSMENT_PROFILES.compliance).toContain(module);
+            }
+            for (const module of TIER_2_COMPLIANCE) {
+                expect(ASSESSMENT_PROFILES.compliance).toContain(module);
+            }
+        });
+        it("full profile should include all tiers", () => {
+            for (const module of ALL_MODULES) {
+                expect(ASSESSMENT_PROFILES.full).toContain(module);
+            }
+        });
+    });
+});
+describe("Module Aliases", () => {
+    it("should map deprecated mcpSpecCompliance to protocolCompliance", () => {
+        expect(MODULE_ALIASES.mcpSpecCompliance).toBe("protocolCompliance");
+    });
+    it("should map deprecated protocolConformance to protocolCompliance", () => {
+        expect(MODULE_ALIASES.protocolConformance).toBe("protocolCompliance");
+    });
+    it("should map deprecated documentation to developerExperience", () => {
+        expect(MODULE_ALIASES.documentation).toBe("developerExperience");
+    });
+    it("should map deprecated usability to developerExperience", () => {
+        expect(MODULE_ALIASES.usability).toBe("developerExperience");
+    });
+    it("should have DEPRECATED_MODULES match MODULE_ALIASES keys", () => {
+        const aliasKeys = Object.keys(MODULE_ALIASES);
+        for (const key of aliasKeys) {
+            expect(DEPRECATED_MODULES.has(key)).toBe(true);
+        }
+        expect(DEPRECATED_MODULES.size).toBe(aliasKeys.length);
+    });
+});
+describe("resolveModuleNames", () => {
+    it("should return unchanged names for non-deprecated modules", () => {
+        const modules = ["functionality", "security", "temporal"];
+        const result = resolveModuleNames(modules, false);
+        expect(result).toEqual(modules);
+    });
+    it("should replace deprecated module names with aliases", () => {
+        const modules = ["mcpSpecCompliance", "documentation"];
+        const result = resolveModuleNames(modules, false);
+        expect(result).toContain("protocolCompliance");
+        expect(result).toContain("developerExperience");
+        expect(result).not.toContain("mcpSpecCompliance");
+        expect(result).not.toContain("documentation");
+    });
+    it("should deduplicate when deprecated and replacement both specified", () => {
+        const modules = ["mcpSpecCompliance", "protocolCompliance"];
+        const result = resolveModuleNames(modules, false);
+        expect(result.length).toBe(1);
+        expect(result).toContain("protocolCompliance");
+    });
+    it("should emit warnings for deprecated modules when warn=true", () => {
+        const consoleSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        const modules = ["documentation"];
+        resolveModuleNames(modules, true);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("deprecated"));
+        consoleSpy.mockRestore();
+    });
+    it("should not emit warnings when warn=false", () => {
+        const consoleSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        const modules = ["documentation"];
+        resolveModuleNames(modules, false);
+        expect(consoleSpy).not.toHaveBeenCalled();
+        consoleSpy.mockRestore();
+    });
+});
+describe("getProfileModules", () => {
+    it("should return modules for quick profile", () => {
+        const modules = getProfileModules("quick");
+        expect(modules).toEqual(["functionality", "security"]);
+    });
+    it("should return modules for security profile", () => {
+        const modules = getProfileModules("security");
+        expect(modules.length).toBe(TIER_1_CORE_SECURITY.length);
+        for (const mod of TIER_1_CORE_SECURITY) {
+            expect(modules).toContain(mod);
+        }
+    });
+    it("should exclude temporal when skipTemporal=true", () => {
+        const modules = getProfileModules("security", { skipTemporal: true });
+        expect(modules).not.toContain("temporal");
+    });
+    it("should exclude externalAPIScanner when hasSourceCode=false", () => {
+        const modules = getProfileModules("full", { hasSourceCode: false });
+        expect(modules).not.toContain("externalAPIScanner");
+    });
+    it("should include externalAPIScanner when hasSourceCode=true", () => {
+        const modules = getProfileModules("full", { hasSourceCode: true });
+        expect(modules).toContain("externalAPIScanner");
+    });
+    it("should handle multiple options together", () => {
+        const modules = getProfileModules("full", {
+            skipTemporal: true,
+            hasSourceCode: false,
+        });
+        expect(modules).not.toContain("temporal");
+        expect(modules).not.toContain("externalAPIScanner");
+    });
+});
+describe("isValidProfileName", () => {
+    it("should return true for valid profile names", () => {
+        expect(isValidProfileName("quick")).toBe(true);
+        expect(isValidProfileName("security")).toBe(true);
+        expect(isValidProfileName("compliance")).toBe(true);
+        expect(isValidProfileName("full")).toBe(true);
+    });
+    it("should return false for invalid profile names", () => {
+        expect(isValidProfileName("invalid")).toBe(false);
+        expect(isValidProfileName("")).toBe(false);
+        expect(isValidProfileName("QUICK")).toBe(false);
+        expect(isValidProfileName("fast")).toBe(false);
+    });
+});
+describe("getProfileHelpText", () => {
+    it("should return non-empty string", () => {
+        const help = getProfileHelpText();
+        expect(help.length).toBeGreaterThan(0);
+    });
+    it("should contain all profile names", () => {
+        const help = getProfileHelpText();
+        expect(help).toContain("quick");
+        expect(help).toContain("security");
+        expect(help).toContain("compliance");
+        expect(help).toContain("full");
+    });
+    it("should contain module counts", () => {
+        const help = getProfileHelpText();
+        expect(help).toContain("Modules:");
+    });
+    it("should contain time estimates", () => {
+        const help = getProfileHelpText();
+        expect(help).toContain("Time:");
+    });
+});
+describe("mapLegacyConfigToModules", () => {
+    it("should return empty array for empty config", () => {
+        const result = mapLegacyConfigToModules({});
+        expect(result).toEqual([]);
+    });
+    it("should return enabled modules", () => {
+        const config = {
+            functionality: true,
+            security: true,
+            temporal: false,
+        };
+        const result = mapLegacyConfigToModules(config);
+        expect(result).toContain("functionality");
+        expect(result).toContain("security");
+        expect(result).not.toContain("temporal");
+    });
+    it("should apply aliases for deprecated names", () => {
+        const config = {
+            documentation: true,
+            mcpSpecCompliance: true,
+        };
+        const result = mapLegacyConfigToModules(config);
+        expect(result).toContain("developerExperience");
+        expect(result).toContain("protocolCompliance");
+        expect(result).not.toContain("documentation");
+        expect(result).not.toContain("mcpSpecCompliance");
+    });
+    it("should deduplicate when both deprecated and new names enabled", () => {
+        const config = {
+            documentation: true,
+            developerExperience: true,
+        };
+        const result = mapLegacyConfigToModules(config);
+        const devExpCount = result.filter((m) => m === "developerExperience").length;
+        expect(devExpCount).toBe(1);
+    });
+});
+describe("modulesToLegacyConfig", () => {
+    it("should return config with all modules disabled by default", () => {
+        const result = modulesToLegacyConfig([]);
+        expect(result.functionality).toBe(false);
+        expect(result.security).toBe(false);
+    });
+    it("should enable specified modules", () => {
+        const result = modulesToLegacyConfig(["functionality", "security"]);
+        expect(result.functionality).toBe(true);
+        expect(result.security).toBe(true);
+        expect(result.temporal).toBe(false);
+    });
+    it("should map protocolCompliance to both old modules", () => {
+        const result = modulesToLegacyConfig(["protocolCompliance"]);
+        expect(result.mcpSpecCompliance).toBe(true);
+        expect(result.protocolConformance).toBe(true);
+    });
+    it("should map developerExperience to both old modules", () => {
+        const result = modulesToLegacyConfig(["developerExperience"]);
+        expect(result.documentation).toBe(true);
+        expect(result.usability).toBe(true);
+    });
+    it("should handle full profile modules", () => {
+        const modules = getProfileModules("full", { hasSourceCode: true });
+        const result = modulesToLegacyConfig(modules);
+        expect(result.functionality).toBe(true);
+        expect(result.security).toBe(true);
+        expect(result.temporal).toBe(true);
+        expect(result.toolAnnotations).toBe(true);
+    });
+});
+describe("Profile Metadata", () => {
+    it("should have descriptions for all profiles", () => {
+        for (const meta of Object.values(PROFILE_METADATA)) {
+            expect(meta.description).toBeTruthy();
+            expect(typeof meta.description).toBe("string");
+        }
+    });
+    it("should have estimated times for all profiles", () => {
+        for (const meta of Object.values(PROFILE_METADATA)) {
+            expect(meta.estimatedTime).toBeTruthy();
+            expect(meta.estimatedTime).toMatch(/~\d+-?\d*\s*minutes?/);
+        }
+    });
+    it("should have tier information for all profiles", () => {
+        for (const meta of Object.values(PROFILE_METADATA)) {
+            expect(Array.isArray(meta.tiers)).toBe(true);
+            expect(meta.tiers.length).toBeGreaterThan(0);
+        }
+    });
+    it("should have correct tier counts", () => {
+        expect(PROFILE_METADATA.quick.tiers.length).toBe(1);
+        expect(PROFILE_METADATA.security.tiers.length).toBe(1);
+        expect(PROFILE_METADATA.compliance.tiers.length).toBe(2);
+        expect(PROFILE_METADATA.full.tiers.length).toBe(4);
+    });
+});

package/build/__tests__/transport.test.js

@@ -0,0 +1,165 @@
+/**
+ * Transport Module Unit Tests
+ *
+ * Tests for transport creation and configuration validation.
+ * Tests focus on input validation and error handling rather than
+ * mocked transport implementations due to ESM limitations.
+ */
+import { describe, it, expect } from "@jest/globals";
+import { createTransport } from "../transport.js";
+describe("Transport Creation", () => {
+    describe("Input Validation", () => {
+        it("should throw error when URL is missing for HTTP transport", () => {
+            const options = {
+                transportType: "http",
+            };
+            expect(() => createTransport(options)).toThrow(/URL must be provided for SSE or HTTP transport types/);
+        });
+        it("should throw error when URL is missing for SSE transport", () => {
+            const options = {
+                transportType: "sse",
+            };
+            expect(() => createTransport(options)).toThrow(/URL must be provided for SSE or HTTP transport types/);
+        });
+        it("should throw error for invalid URL format", () => {
+            const options = {
+                transportType: "http",
+                url: ":::invalid-url",
+            };
+            expect(() => createTransport(options)).toThrow(/Failed to create transport/);
+        });
+        it("should throw error for unsupported transport type", () => {
+            const options = {
+                transportType: "websocket",
+                url: "ws://localhost:3000",
+            };
+            expect(() => createTransport(options)).toThrow(/Unsupported transport type/);
+        });
+    });
+    describe("STDIO Transport", () => {
+        it("should create transport for valid stdio options", () => {
+            const options = {
+                transportType: "stdio",
+                command: "python",
+                args: ["server.py"],
+            };
+            // Should not throw
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+        it("should handle missing args", () => {
+            const options = {
+                transportType: "stdio",
+                command: "node",
+            };
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+        it("should handle empty command", () => {
+            const options = {
+                transportType: "stdio",
+                command: "",
+            };
+            // Should not throw - empty command is handled by findActualExecutable
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+    });
+    describe("HTTP Transport", () => {
+        it("should create transport for valid HTTP options", () => {
+            const options = {
+                transportType: "http",
+                url: "http://localhost:3000/mcp",
+            };
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+        it("should create transport with headers", () => {
+            const options = {
+                transportType: "http",
+                url: "http://localhost:3000/mcp",
+                headers: {
+                    Authorization: "Bearer token",
+                },
+            };
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+        it("should handle HTTPS URLs", () => {
+            const options = {
+                transportType: "http",
+                url: "https://api.example.com/mcp",
+            };
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+    });
+    describe("SSE Transport", () => {
+        it("should create transport for valid SSE options", () => {
+            const options = {
+                transportType: "sse",
+                url: "http://localhost:3000/sse",
+            };
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+        it("should create transport with headers", () => {
+            const options = {
+                transportType: "sse",
+                url: "http://localhost:3000/sse",
+                headers: {
+                    "X-API-Key": "secret",
+                },
+            };
+            const transport = createTransport(options);
+            expect(transport).toBeDefined();
+        });
+    });
+});
+describe("TransportOptions Type", () => {
+    it("should accept all valid transport types", () => {
+        const stdioOptions = {
+            transportType: "stdio",
+            command: "node",
+            args: ["server.js"],
+        };
+        const httpOptions = {
+            transportType: "http",
+            url: "http://localhost:3000/mcp",
+        };
+        const sseOptions = {
+            transportType: "sse",
+            url: "http://localhost:3000/sse",
+        };
+        // Type checking - these should compile without errors
+        expect(stdioOptions.transportType).toBe("stdio");
+        expect(httpOptions.transportType).toBe("http");
+        expect(sseOptions.transportType).toBe("sse");
+    });
+    it("should allow optional headers for HTTP/SSE", () => {
+        const withHeaders = {
+            transportType: "http",
+            url: "http://localhost:3000/mcp",
+            headers: { "Content-Type": "application/json" },
+        };
+        const withoutHeaders = {
+            transportType: "http",
+            url: "http://localhost:3000/mcp",
+        };
+        expect(withHeaders.headers).toBeDefined();
+        expect(withoutHeaders.headers).toBeUndefined();
+    });
+    it("should allow optional command args", () => {
+        const withArgs = {
+            transportType: "stdio",
+            command: "python",
+            args: ["-m", "server"],
+        };
+        const withoutArgs = {
+            transportType: "stdio",
+            command: "python",
+        };
+        expect(withArgs.args).toEqual(["-m", "server"]);
+        expect(withoutArgs.args).toBeUndefined();
+    });
+});

package/build/assess-full.js

@@ -1010,7 +1010,8 @@ function parseArgs() {
         }
     }
     // Validate mutual exclusivity of --profile, --skip-modules, and --only-modules
-    if (options.profile && (options.skipModules?.length || options.onlyModules?.length)) {
+    if (options.profile &&
+        (options.skipModules?.length || options.onlyModules?.length)) {
         console.error("Error: --profile cannot be used with --skip-modules or --only-modules");
         setTimeout(() => process.exit(1), 10);
         options.helpRequested = true;

package/build/profiles.js

@@ -86,30 +86,34 @@ export const ALL_MODULES = [
 /**
  * Assessment profile definitions
  * Each profile includes a specific set of modules optimized for the use case.
+ *
+ * Note: Time estimates are based on testing a server with ~30 tools.
+ * The SecurityAssessor runs 23 attack patterns per tool (~3400+ tests),
+ * which dominates runtime across all profiles that include it.
  */
 export const ASSESSMENT_PROFILES = {
     /**
      * Quick profile: Minimal testing for fast CI/CD checks
      * Use when: Pre-commit hooks, quick validation
-     * Time: ~30 seconds
+     * Time: ~3-4 minutes (security module dominates)
      */
     quick: ["functionality", "security"],
     /**
      * Security profile: Core security modules (Tier 1)
      * Use when: Security-focused audits, vulnerability scanning
-     * Time: ~2-3 minutes
+     * Time: ~8-10 minutes
      */
     security: [...TIER_1_CORE_SECURITY],
     /**
      * Compliance profile: Security + Directory compliance (Tier 1 + 2)
      * Use when: Pre-submission validation for MCP Directory
-     * Time: ~5 minutes
+     * Time: ~8-10 minutes
      */
     compliance: [...TIER_1_CORE_SECURITY, ...TIER_2_COMPLIANCE],
     /**
      * Full profile: All modules (Tier 1 + 2 + 3 + 4)
      * Use when: Comprehensive audits, initial server review
-     * Time: ~10-15 minutes
+     * Time: ~8-12 minutes
      */
     full: [
         ...TIER_1_CORE_SECURITY,
@@ -121,25 +125,25 @@ export const ASSESSMENT_PROFILES = {
 export const PROFILE_METADATA = {
     quick: {
         description: "Fast validation (functionality + security only)",
-        estimatedTime: "~30 seconds",
+        estimatedTime: "~3-4 minutes",
         moduleCount: ASSESSMENT_PROFILES.quick.length,
         tiers: ["Tier 1 (partial)"],
     },
     security: {
         description: "Core security modules for vulnerability scanning",
-        estimatedTime: "~2-3 minutes",
+        estimatedTime: "~8-10 minutes",
         moduleCount: ASSESSMENT_PROFILES.security.length,
         tiers: ["Tier 1 (Core Security)"],
     },
     compliance: {
         description: "Security + MCP Directory compliance validation",
-        estimatedTime: "~5 minutes",
+        estimatedTime: "~8-10 minutes",
         moduleCount: ASSESSMENT_PROFILES.compliance.length,
         tiers: ["Tier 1 (Core Security)", "Tier 2 (Compliance)"],
     },
     full: {
         description: "Comprehensive audit with all assessment modules",
-        estimatedTime: "~10-15 minutes",
+        estimatedTime: "~8-12 minutes",
         moduleCount: ASSESSMENT_PROFILES.full.length,
         tiers: [
             "Tier 1 (Core Security)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment-cli",
-  "version": "1.25.0",
+  "version": "1.25.4",
   "description": "CLI for the Enhanced MCP Inspector with assessment capabilities",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",
@@ -30,13 +30,19 @@
   "scripts": {
     "build": "tsc",
     "postbuild": "node scripts/make-executable.js",
-    "test": "node scripts/cli-tests.js && node scripts/cli-tool-tests.js && node scripts/cli-header-tests.js && node scripts/cli-validation-tests.js",
+    "test": "npm run test:unit && npm run test:integration",
+    "test:unit": "node --experimental-vm-modules ../node_modules/.bin/jest --config jest.config.cjs",
+    "test:integration": "node scripts/cli-tests.js && node scripts/cli-tool-tests.js && node scripts/cli-header-tests.js && node scripts/cli-validation-tests.js",
     "test:cli": "node scripts/cli-tests.js",
     "test:cli-tools": "node scripts/cli-tool-tests.js",
     "test:cli-headers": "node scripts/cli-header-tests.js",
     "test:cli-validation": "node scripts/cli-validation-tests.js"
   },
-  "devDependencies": {},
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.0"
+  },
   "dependencies": {
     "@bryan-thompson/inspector-assessment-client": "^1.5.0",
     "@modelcontextprotocol/sdk": "^1.24.3",