@bryan-thompson/inspector-assessment-cli 1.39.0 → 1.40.1

package/build/__tests__/flag-parsing.test.js

@@ -388,7 +388,10 @@ describe("Module Name Validation", () => {
     const VALID_MODULE_NAMES = [
         "functionality",
         "security",
+        "documentation",
         "errorHandling",
+        "usability",
+        "mcpSpecCompliance", // deprecated, use protocolCompliance
         "protocolCompliance",
         "aupCompliance",
         "toolAnnotations",
@@ -399,9 +402,12 @@ describe("Module Name Validation", () => {
         "resources",
         "prompts",
         "crossCapability",
+        "protocolConformance", // deprecated, use protocolCompliance
         "developerExperience",
         "portability",
         "externalAPIScanner",
+        "fileModularization",
+        "conformance",
     ];
     function validateModuleNames(input) {
         const names = input
@@ -840,3 +846,610 @@ describe("parseArgs Zod Schema Integration", () => {
         });
     });
 });
+/**
+ * Transport Flag Tests (--http, --sse)
+ *
+ * Tests for the convenience transport flags that allow quick testing
+ * without creating a config file.
+ */
+describe("Transport Flags (--http, --sse)", () => {
+    let processExitSpy;
+    let consoleErrorSpy;
+    beforeEach(() => {
+        jest.useFakeTimers();
+        processExitSpy = jest
+            .spyOn(process, "exit")
+            .mockImplementation((() => { }));
+        consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        jest.runAllTimers();
+        jest.useRealTimers();
+        processExitSpy?.mockRestore();
+        consoleErrorSpy?.mockRestore();
+    });
+    describe("--http flag", () => {
+        it("should accept valid HTTP URL", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+            ]);
+            expect(result.httpUrl).toBe("http://localhost:10900/mcp");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should accept valid HTTPS URL", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "https://api.example.com/mcp",
+            ]);
+            expect(result.httpUrl).toBe("https://api.example.com/mcp");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should reject invalid URL", () => {
+            const result = parseArgs(["test-server", "--http", "not-a-valid-url"]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Invalid URL for --http"));
+        });
+        it("should reject missing URL argument", () => {
+            const result = parseArgs(["test-server", "--http"]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--http requires a URL argument"));
+        });
+        it("should reject when next argument is another flag", () => {
+            const result = parseArgs(["test-server", "--http", "--verbose"]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--http requires a URL argument"));
+        });
+        it("should reject non-HTTP protocol (file://)", () => {
+            const result = parseArgs(["test-server", "--http", "file:///etc/passwd"]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--http requires HTTP or HTTPS URL, got: file:"));
+        });
+        it("should reject non-HTTP protocol (ftp://)", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "ftp://example.com/file",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--http requires HTTP or HTTPS URL, got: ftp:"));
+        });
+    });
+    describe("--sse flag", () => {
+        it("should accept valid SSE URL", () => {
+            const result = parseArgs([
+                "test-server",
+                "--sse",
+                "http://localhost:9002/sse",
+            ]);
+            expect(result.sseUrl).toBe("http://localhost:9002/sse");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should accept valid HTTPS SSE URL", () => {
+            const result = parseArgs([
+                "test-server",
+                "--sse",
+                "https://api.example.com/sse",
+            ]);
+            expect(result.sseUrl).toBe("https://api.example.com/sse");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should reject invalid URL", () => {
+            const result = parseArgs(["test-server", "--sse", "invalid-url"]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Invalid URL for --sse"));
+        });
+        it("should reject missing URL argument", () => {
+            const result = parseArgs(["test-server", "--sse"]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--sse requires a URL argument"));
+        });
+        it("should reject non-HTTP protocol (file://)", () => {
+            const result = parseArgs(["test-server", "--sse", "file:///etc/passwd"]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--sse requires HTTP or HTTPS URL, got: file:"));
+        });
+    });
+    describe("mutual exclusivity", () => {
+        it("should reject --http with --config", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "--config",
+                "config.json",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--http/--sse cannot be used with --config"));
+        });
+        it("should reject --sse with --config", () => {
+            const result = parseArgs([
+                "test-server",
+                "--sse",
+                "http://localhost:9002/sse",
+                "--config",
+                "config.json",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--http/--sse cannot be used with --config"));
+        });
+        it("should reject --http with --sse", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "--sse",
+                "http://localhost:9002/sse",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--http and --sse are mutually exclusive"));
+        });
+        it("should allow --http without --config or --sse", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+            ]);
+            expect(result.httpUrl).toBe("http://localhost:10900/mcp");
+            expect(result.sseUrl).toBeUndefined();
+            expect(result.serverConfigPath).toBeUndefined();
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should allow --sse without --config or --http", () => {
+            const result = parseArgs([
+                "test-server",
+                "--sse",
+                "http://localhost:9002/sse",
+            ]);
+            expect(result.sseUrl).toBe("http://localhost:9002/sse");
+            expect(result.httpUrl).toBeUndefined();
+            expect(result.serverConfigPath).toBeUndefined();
+            expect(result.helpRequested).toBeFalsy();
+        });
+    });
+    describe("combined with other options", () => {
+        it("should work with --http and --temporal-invocations", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "--temporal-invocations",
+                "5",
+            ]);
+            expect(result.httpUrl).toBe("http://localhost:10900/mcp");
+            expect(result.temporalInvocations).toBe(5);
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --sse and --profile", () => {
+            const result = parseArgs([
+                "test-server",
+                "--sse",
+                "http://localhost:9002/sse",
+                "--profile",
+                "quick",
+            ]);
+            expect(result.sseUrl).toBe("http://localhost:9002/sse");
+            expect(result.profile).toBe("quick");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --http and --output", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "--output",
+                "/tmp/results.json",
+            ]);
+            expect(result.httpUrl).toBe("http://localhost:10900/mcp");
+            expect(result.outputPath).toBe("/tmp/results.json");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --http and --conformance", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "--conformance",
+            ]);
+            expect(result.httpUrl).toBe("http://localhost:10900/mcp");
+            expect(result.conformanceEnabled).toBe(true);
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --sse and --conformance", () => {
+            const result = parseArgs([
+                "test-server",
+                "--sse",
+                "http://localhost:9002/sse",
+                "--conformance",
+            ]);
+            expect(result.sseUrl).toBe("http://localhost:9002/sse");
+            expect(result.conformanceEnabled).toBe(true);
+            expect(result.helpRequested).toBeFalsy();
+        });
+    });
+});
+/**
+ * Module Flag Tests (--module, -m)
+ *
+ * Tests for the single module execution flag that bypasses orchestrator.
+ * Issue #184: Single module runner for focused testing without orchestration overhead.
+ */
+describe("Module Flag (--module, -m)", () => {
+    let processExitSpy;
+    let consoleErrorSpy;
+    beforeEach(() => {
+        jest.useFakeTimers();
+        processExitSpy = jest
+            .spyOn(process, "exit")
+            .mockImplementation((() => { }));
+        consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        jest.runAllTimers();
+        jest.useRealTimers();
+        processExitSpy?.mockRestore();
+        consoleErrorSpy?.mockRestore();
+    });
+    describe("valid module names", () => {
+        it("should accept valid module name with long flag", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "toolAnnotations",
+            ]);
+            expect(result.singleModule).toBe("toolAnnotations");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should accept valid module name with short flag", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "-m",
+                "security",
+            ]);
+            expect(result.singleModule).toBe("security");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should accept all valid core module names", () => {
+            const coreModules = [
+                "functionality",
+                "security",
+                "documentation",
+                "errorHandling",
+                "usability",
+                "mcpSpecCompliance",
+                "aupCompliance",
+                "toolAnnotations",
+                "prohibitedLibraries",
+                "externalAPIScanner",
+                "authentication",
+                "temporal",
+                "resources",
+                "prompts",
+                "crossCapability",
+                "protocolConformance",
+            ];
+            for (const moduleName of coreModules) {
+                consoleErrorSpy.mockClear();
+                const result = parseArgs([
+                    "test-server",
+                    "--config",
+                    "config.json",
+                    "--module",
+                    moduleName,
+                ]);
+                expect(result.singleModule).toBe(moduleName);
+                expect(result.helpRequested).toBeFalsy();
+            }
+        });
+        it("should accept optional module names", () => {
+            const optionalModules = ["manifestValidation", "portability"];
+            for (const moduleName of optionalModules) {
+                consoleErrorSpy.mockClear();
+                const result = parseArgs([
+                    "test-server",
+                    "--config",
+                    "config.json",
+                    "--module",
+                    moduleName,
+                ]);
+                expect(result.singleModule).toBe(moduleName);
+                expect(result.helpRequested).toBeFalsy();
+            }
+        });
+    });
+    describe("invalid module names", () => {
+        it("should reject invalid module name", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "invalidModule",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Invalid module name"));
+        });
+        it("should reject missing module argument", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--module requires a module name"));
+        });
+        it("should reject when next argument is another flag", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "--verbose",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--module requires a module name"));
+        });
+        it("should reject case-sensitive mismatch", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "SECURITY",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Invalid module name"));
+        });
+        it("should reject module name with typo", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "functionalaty",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Invalid module name"));
+        });
+    });
+    describe("mutual exclusivity with orchestrator flags", () => {
+        it("should reject --module with --profile", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "security",
+                "--profile",
+                "quick",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--module cannot be used with --skip-modules, --only-modules, or --profile"));
+        });
+        it("should reject --module with --skip-modules", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "security",
+                "--skip-modules",
+                "temporal",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--module cannot be used with"));
+        });
+        it("should reject --module with --only-modules", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "security",
+                "--only-modules",
+                "functionality",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--module cannot be used with"));
+        });
+        it("should reject --profile with --module (order reversed)", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--profile",
+                "quick",
+                "--module",
+                "security",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--module cannot be used with"));
+        });
+    });
+    describe("combined with transport flags", () => {
+        it("should work with --http", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "--module",
+                "security",
+            ]);
+            expect(result.httpUrl).toBe("http://localhost:10900/mcp");
+            expect(result.singleModule).toBe("security");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --sse", () => {
+            const result = parseArgs([
+                "test-server",
+                "--sse",
+                "http://localhost:9002/sse",
+                "--module",
+                "functionality",
+            ]);
+            expect(result.sseUrl).toBe("http://localhost:9002/sse");
+            expect(result.singleModule).toBe("functionality");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --config", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "temporal",
+            ]);
+            expect(result.serverConfigPath).toBe("config.json");
+            expect(result.singleModule).toBe("temporal");
+            expect(result.helpRequested).toBeFalsy();
+        });
+    });
+    describe("combined with other compatible flags", () => {
+        it("should work with --output", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "security",
+                "--output",
+                "/tmp/results.json",
+            ]);
+            expect(result.singleModule).toBe("security");
+            expect(result.outputPath).toBe("/tmp/results.json");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --verbose", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "toolAnnotations",
+                "--verbose",
+            ]);
+            expect(result.singleModule).toBe("toolAnnotations");
+            expect(result.verbose).toBe(true);
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --log-level", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "errorHandling",
+                "--log-level",
+                "debug",
+            ]);
+            expect(result.singleModule).toBe("errorHandling");
+            expect(result.logLevel).toBe("debug");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --temporal-invocations", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "temporal",
+                "--temporal-invocations",
+                "10",
+            ]);
+            expect(result.singleModule).toBe("temporal");
+            expect(result.temporalInvocations).toBe(10);
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --conformance", () => {
+            const result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "--module",
+                "protocolConformance",
+                "--conformance",
+            ]);
+            expect(result.singleModule).toBe("protocolConformance");
+            expect(result.conformanceEnabled).toBe(true);
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should work with --format", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "--module",
+                "security",
+                "--format",
+                "markdown",
+            ]);
+            expect(result.singleModule).toBe("security");
+            expect(result.format).toBe("markdown");
+            expect(result.helpRequested).toBeFalsy();
+        });
+    });
+    describe("short flag behavior", () => {
+        it("should accept -m with all transport types", () => {
+            // Test with --http
+            let result = parseArgs([
+                "test-server",
+                "--http",
+                "http://localhost:10900/mcp",
+                "-m",
+                "security",
+            ]);
+            expect(result.singleModule).toBe("security");
+            expect(result.helpRequested).toBeFalsy();
+            // Test with --sse
+            consoleErrorSpy.mockClear();
+            result = parseArgs([
+                "test-server",
+                "--sse",
+                "http://localhost:9002/sse",
+                "-m",
+                "functionality",
+            ]);
+            expect(result.singleModule).toBe("functionality");
+            expect(result.helpRequested).toBeFalsy();
+            // Test with --config
+            consoleErrorSpy.mockClear();
+            result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "-m",
+                "temporal",
+            ]);
+            expect(result.singleModule).toBe("temporal");
+            expect(result.helpRequested).toBeFalsy();
+        });
+        it("should reject -m with missing argument", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "-m",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("--module requires a module name"));
+        });
+        it("should reject -m with invalid module", () => {
+            const result = parseArgs([
+                "test-server",
+                "--config",
+                "config.json",
+                "-m",
+                "notAModule",
+            ]);
+            expect(result.helpRequested).toBe(true);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Invalid module name"));
+        });
+    });
+});

package/build/assess-full.js

@@ -12,8 +12,8 @@
 import { ScopedListenerConfig } from "./lib/event-config.js";
 // Import from extracted modules
 import { parseArgs } from "./lib/cli-parser.js";
-import { runFullAssessment } from "./lib/assessment-runner.js";
-import { saveResults, saveTieredResults, saveSummaryOnly, displaySummary, } from "./lib/result-output.js";
+import { runFullAssessment, runSingleModule } from "./lib/assessment-runner.js";
+import { saveResults, saveTieredResults, saveSummaryOnly, displaySummary, saveSingleModuleResults, displaySingleModuleSummary, } from "./lib/result-output.js";
 import { handleComparison, displayComparisonSummary, } from "./lib/comparison-handler.js";
 import { shouldAutoTier, formatTokenEstimate, } from "../../client/lib/lib/assessment/summarizer/index.js";
 // ============================================================================
@@ -35,6 +35,23 @@ async function main() {
         }
         // Apply scoped listener configuration for assessment
         listenerConfig.apply();
+        // Single module mode - bypass orchestrator for lightweight execution (Issue #184)
+        if (options.singleModule) {
+            const result = await runSingleModule(options.singleModule, options);
+            if (!options.jsonOnly) {
+                displaySingleModuleSummary(result);
+            }
+            const outputPath = saveSingleModuleResults(options.serverName, options.singleModule, result, options);
+            if (options.jsonOnly) {
+                console.log(outputPath);
+            }
+            else {
+                console.log(`\n📄 Results saved to: ${outputPath}\n`);
+            }
+            const exitCode = result.status === "FAIL" ? 1 : 0;
+            setTimeout(() => process.exit(exitCode), 10);
+            return;
+        }
         const results = await runFullAssessment(options);
         // Pre-flight mode handles its own output and exit
         if (options.preflightOnly) {