@bryan-thompson/inspector-assessment-cli 1.38.3 → 1.40.0

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

@@ -840,3 +840,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) {

package/build/lib/assessment-runner/assessment-executor.js

@@ -43,9 +43,34 @@ export async function runFullAssessment(options) {
     if (!options.jsonOnly) {
         console.log(`\n🔍 Starting full assessment for: ${options.serverName}`);
     }
-    const serverConfig = loadServerConfig(options.serverName, options.serverConfigPath);
-    if (!options.jsonOnly) {
-        console.log("✅ Server config loaded");
+    // Determine server config: --http/--sse flags take precedence over --config
+    let serverConfig;
+    if (options.httpUrl) {
+        // Direct HTTP URL provided via --http flag (no config file needed)
+        serverConfig = {
+            transport: "http",
+            url: options.httpUrl,
+        };
+        if (!options.jsonOnly) {
+            console.log(`✅ Using HTTP transport: ${options.httpUrl}`);
+        }
+    }
+    else if (options.sseUrl) {
+        // Direct SSE URL provided via --sse flag (no config file needed)
+        serverConfig = {
+            transport: "sse",
+            url: options.sseUrl,
+        };
+        if (!options.jsonOnly) {
+            console.log(`✅ Using SSE transport: ${options.sseUrl}`);
+        }
+    }
+    else {
+        // Load from config file (existing behavior)
+        serverConfig = loadServerConfig(options.serverName, options.serverConfigPath);
+        if (!options.jsonOnly) {
+            console.log("✅ Server config loaded");
+        }
     }
     // Phase 1: Discovery
     const discoveryStart = Date.now();

package/build/lib/assessment-runner/index.js

@@ -20,3 +20,5 @@ export { createCallToolWrapper } from "./tool-wrapper.js";
 export { buildConfig } from "./config-builder.js";
 // Assessment Execution
 export { runFullAssessment } from "./assessment-executor.js";
+// Single Module Execution (Issue #184)
+export { runSingleModule, getValidModuleNames, } from "./single-module-runner.js";

package/build/lib/assessment-runner/single-module-runner.js

@@ -0,0 +1,315 @@
+/**
+ * Single Module Runner
+ *
+ * Lightweight execution for individual assessment modules via --module flag.
+ * Bypasses full orchestration for faster, targeted assessment.
+ *
+ * @module cli/lib/assessment-runner/single-module-runner
+ * @see GitHub Issue #184
+ */
+import { ASSESSOR_DEFINITION_MAP, ASSESSOR_DEFINITIONS, } from "../../../../client/lib/services/assessment/registry/AssessorDefinitions.js";
+import { DEFAULT_CONTEXT_REQUIREMENTS } from "../../../../client/lib/services/assessment/registry/types.js";
+import { loadServerConfig } from "./server-config.js";
+import { loadSourceFiles } from "./source-loader.js";
+import { resolveSourcePath } from "./path-resolver.js";
+import { connectToServer } from "./server-connection.js";
+import { createCallToolWrapper } from "./tool-wrapper.js";
+import { buildConfig } from "./config-builder.js";
+import { getToolsWithPreservedHints } from "./tools-with-hints.js";
+/**
+ * Get all valid module names for --module validation.
+ */
+export function getValidModuleNames() {
+    return ASSESSOR_DEFINITIONS.map((def) => def.id);
+}
+/**
+ * Run a single assessment module directly without orchestration.
+ *
+ * This provides lightweight execution for targeted validation:
+ * - Builds only the context required by the specific module
+ * - Skips orchestrator phase ordering
+ * - Returns focused output
+ *
+ * @param moduleName - The module ID to run (e.g., 'toolAnnotations', 'functionality')
+ * @param options - CLI assessment options
+ * @returns Single module result
+ */
+export async function runSingleModule(moduleName, options) {
+    const definition = ASSESSOR_DEFINITION_MAP.get(moduleName);
+    if (!definition) {
+        const validModules = getValidModuleNames().join(", ");
+        throw new Error(`Unknown module: ${moduleName}\nValid modules: ${validModules}`);
+    }
+    if (!options.jsonOnly) {
+        console.log(`\n🎯 Running single module: ${definition.displayName}`);
+    }
+    // Build server config (respects --http/--sse from Issue #183)
+    let serverConfig;
+    if (options.httpUrl) {
+        serverConfig = { transport: "http", url: options.httpUrl };
+        if (!options.jsonOnly) {
+            console.log(`✅ Using HTTP transport: ${options.httpUrl}`);
+        }
+    }
+    else if (options.sseUrl) {
+        serverConfig = { transport: "sse", url: options.sseUrl };
+        if (!options.jsonOnly) {
+            console.log(`✅ Using SSE transport: ${options.sseUrl}`);
+        }
+    }
+    else {
+        serverConfig = loadServerConfig(options.serverName, options.serverConfigPath);
+        if (!options.jsonOnly) {
+            console.log("✅ Server config loaded");
+        }
+    }
+    const client = await connectToServer(serverConfig);
+    try {
+        if (!options.jsonOnly) {
+            console.log("✅ Connected to MCP server");
+        }
+        // Get context requirements (use default if not specified)
+        const requirements = definition.contextRequirements || DEFAULT_CONTEXT_REQUIREMENTS;
+        // Build minimal context based on module requirements
+        const context = await buildMinimalContext(client, definition, requirements, options, serverConfig);
+        // Instantiate and run the assessor
+        const config = buildConfig(options);
+        const assessor = new definition.assessorClass(config);
+        // Apply custom setup if defined (e.g., ToolAnnotationAssessor pattern loading)
+        if (definition.customSetup) {
+            const { createLogger } = await import("../../../../client/lib/services/assessment/lib/logger.js");
+            const logger = createLogger(config.logging?.level || "info");
+            definition.customSetup(assessor, config, logger);
+        }
+        if (!options.jsonOnly) {
+            console.log(`\n🏃 Running ${definition.displayName} assessment...`);
+        }
+        const startTime = Date.now();
+        const result = await assessor.assess(context);
+        const executionTime = Date.now() - startTime;
+        // Estimate test count using the definition's estimator
+        const estimatedTestCount = definition.estimateTests(context, config);
+        const singleResult = {
+            timestamp: new Date().toISOString(),
+            serverName: options.serverName,
+            module: moduleName,
+            displayName: definition.displayName,
+            result,
+            status: extractStatus(result),
+            executionTime,
+            estimatedTestCount,
+            phase: definition.phase,
+        };
+        return singleResult;
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Build minimal AssessmentContext based on module requirements.
+ * Only fetches/prepares what the specific module needs.
+ */
+async function buildMinimalContext(client, definition, requirements, options, serverConfig) {
+    const config = buildConfig(options);
+    // Start with minimal context
+    const context = {
+        serverName: options.serverName,
+        config,
+    };
+    // Fetch tools if needed
+    if (requirements.needsTools) {
+        context.tools = await getToolsWithPreservedHints(client);
+        if (!options.jsonOnly) {
+            console.log(`🔧 Found ${context.tools.length} tool${context.tools.length !== 1 ? "s" : ""}`);
+        }
+    }
+    else {
+        context.tools = [];
+    }
+    // Setup callTool wrapper if needed
+    if (requirements.needsCallTool) {
+        context.callTool = createCallToolWrapper(client);
+    }
+    // Setup listTools function if needed (for TemporalAssessor baseline)
+    if (requirements.needsListTools) {
+        context.listTools = async () => {
+            return getToolsWithPreservedHints(client);
+        };
+    }
+    // Fetch resources if needed
+    if (requirements.needsResources) {
+        try {
+            const resourcesResponse = await client.listResources();
+            context.resources = (resourcesResponse.resources || []).map((r) => ({
+                uri: r.uri,
+                name: r.name,
+                description: r.description,
+                mimeType: r.mimeType,
+            }));
+            // Also get resource templates
+            try {
+                const templatesResponse = await client.listResourceTemplates();
+                context.resourceTemplates = (templatesResponse.resourceTemplates || []).map((rt) => ({
+                    uriTemplate: rt.uriTemplate,
+                    name: rt.name,
+                    description: rt.description,
+                    mimeType: rt.mimeType,
+                }));
+            }
+            catch {
+                context.resourceTemplates = [];
+            }
+            // Setup readResource wrapper
+            context.readResource = async (uri) => {
+                const response = await client.readResource({ uri });
+                if (response.contents && response.contents.length > 0) {
+                    const content = response.contents[0];
+                    if ("text" in content && content.text) {
+                        return content.text;
+                    }
+                    if ("blob" in content && content.blob) {
+                        return content.blob;
+                    }
+                }
+                return "";
+            };
+            if (!options.jsonOnly && context.resources.length > 0) {
+                console.log(`📦 Found ${context.resources.length} resource(s) and ${context.resourceTemplates?.length || 0} template(s)`);
+            }
+        }
+        catch {
+            context.resources = [];
+            context.resourceTemplates = [];
+            if (!options.jsonOnly) {
+                console.log("📦 Resources not supported by server");
+            }
+        }
+    }
+    // Fetch prompts if needed
+    if (requirements.needsPrompts) {
+        try {
+            const promptsResponse = await client.listPrompts();
+            context.prompts = (promptsResponse.prompts || []).map((p) => ({
+                name: p.name,
+                description: p.description,
+                arguments: p.arguments?.map((a) => ({
+                    name: a.name,
+                    description: a.description,
+                    required: a.required,
+                })),
+            }));
+            // Setup getPrompt wrapper
+            context.getPrompt = async (name, args) => {
+                const response = await client.getPrompt({ name, arguments: args });
+                return {
+                    messages: (response.messages || []).map((m) => ({
+                        role: m.role,
+                        content: typeof m.content === "string"
+                            ? m.content
+                            : JSON.stringify(m.content),
+                    })),
+                };
+            };
+            if (!options.jsonOnly && context.prompts.length > 0) {
+                console.log(`💬 Found ${context.prompts.length} prompt(s)`);
+            }
+        }
+        catch {
+            context.prompts = [];
+            if (!options.jsonOnly) {
+                console.log("💬 Prompts not supported by server");
+            }
+        }
+    }
+    // Load source code if needed and path provided
+    if (requirements.needsSourceCode && options.sourceCodePath) {
+        const resolvedSourcePath = resolveSourcePath(options.sourceCodePath);
+        const { existsSync } = await import("fs");
+        if (existsSync(resolvedSourcePath)) {
+            const sourceFiles = loadSourceFiles(resolvedSourcePath, options.debugSource);
+            context.sourceCodeFiles = sourceFiles.sourceCodeFiles;
+            context.sourceCodePath = options.sourceCodePath;
+            context.manifestJson = sourceFiles.manifestJson;
+            context.manifestRaw = sourceFiles.manifestRaw;
+            context.packageJson = sourceFiles.packageJson;
+            context.readmeContent = sourceFiles.readmeContent;
+            if (!options.jsonOnly) {
+                console.log(`📁 Loaded source files from: ${resolvedSourcePath}`);
+            }
+        }
+        else if (!options.jsonOnly) {
+            console.log(`⚠️  Source path not found: ${options.sourceCodePath} (module may have reduced coverage)`);
+        }
+    }
+    // Load manifest specifically if needed (for ManifestValidationAssessor)
+    if (requirements.needsManifest && options.sourceCodePath) {
+        const resolvedSourcePath = resolveSourcePath(options.sourceCodePath);
+        const { existsSync } = await import("fs");
+        if (existsSync(resolvedSourcePath)) {
+            const sourceFiles = loadSourceFiles(resolvedSourcePath, options.debugSource);
+            context.manifestJson = sourceFiles.manifestJson;
+            context.manifestRaw = sourceFiles.manifestRaw;
+        }
+    }
+    // Get server info if needed (for ProtocolComplianceAssessor)
+    if (requirements.needsServerInfo) {
+        const rawServerInfo = client.getServerVersion();
+        const rawServerCapabilities = client.getServerCapabilities();
+        context.serverInfo = rawServerInfo
+            ? {
+                name: rawServerInfo.name || "unknown",
+                version: rawServerInfo.version,
+                metadata: rawServerInfo.metadata,
+            }
+            : undefined;
+        context.serverCapabilities =
+            rawServerCapabilities ??
+                undefined;
+        // Set serverUrl for conformance tests when HTTP/SSE transport
+        if (serverConfig.url && !config.serverUrl) {
+            config.serverUrl = serverConfig.url;
+        }
+    }
+    return context;
+}
+/**
+ * Extract status from assessment result.
+ * Handles various result structures from different assessors.
+ */
+function extractStatus(result) {
+    if (!result || typeof result !== "object") {
+        return "UNKNOWN";
+    }
+    const r = result;
+    // Check for direct status field
+    if (typeof r.status === "string") {
+        return r.status;
+    }
+    // Check for overallStatus field
+    if (typeof r.overallStatus === "string") {
+        return r.overallStatus;
+    }
+    // Check for overall field with status
+    if (r.overall && typeof r.overall === "object") {
+        const overall = r.overall;
+        if (typeof overall.status === "string") {
+            return overall.status;
+        }
+    }
+    // Derive from vulnerabilities/issues count
+    if (Array.isArray(r.vulnerabilities) && r.vulnerabilities.length > 0) {
+        return "FAIL";
+    }
+    if (Array.isArray(r.issues) && r.issues.length > 0) {
+        return "FAIL";
+    }
+    // Check for pass/fail counts
+    if (typeof r.passCount === "number" && typeof r.failCount === "number") {
+        if (r.failCount > 0)
+            return "FAIL";
+        if (r.passCount > 0)
+            return "PASS";
+    }
+    return "UNKNOWN";
+}

package/build/lib/cli-parser.js

@@ -200,6 +200,89 @@ export function parseArgs(argv) {
             case "--skip-temporal":
                 options.skipTemporal = true;
                 break;
+            case "--http": {
+                const httpUrlValue = args[++i];
+                if (!httpUrlValue || httpUrlValue.startsWith("-")) {
+                    console.error("Error: --http requires a URL argument");
+                    console.error("  Example: --http http://localhost:10900/mcp");
+                    setTimeout(() => process.exit(1), 10);
+                    options.helpRequested = true;
+                    return options;
+                }
+                try {
+                    const parsedHttpUrl = new URL(httpUrlValue);
+                    // Validate protocol is HTTP or HTTPS (reject file://, ftp://, etc.)
+                    if (parsedHttpUrl.protocol !== "http:" &&
+                        parsedHttpUrl.protocol !== "https:") {
+                        console.error(`Error: --http requires HTTP or HTTPS URL, got: ${parsedHttpUrl.protocol}`);
+                        console.error("  Expected format: http://hostname:port/path or https://hostname:port/path");
+                        setTimeout(() => process.exit(1), 10);
+                        options.helpRequested = true;
+                        return options;
+                    }
+                    options.httpUrl = httpUrlValue;
+                }
+                catch {
+                    console.error(`Error: Invalid URL for --http: ${httpUrlValue}`);
+                    console.error("  Expected format: http://hostname:port/path or https://hostname:port/path");
+                    setTimeout(() => process.exit(1), 10);
+                    options.helpRequested = true;
+                    return options;
+                }
+                break;
+            }
+            case "--sse": {
+                const sseUrlValue = args[++i];
+                if (!sseUrlValue || sseUrlValue.startsWith("-")) {
+                    console.error("Error: --sse requires a URL argument");
+                    console.error("  Example: --sse http://localhost:9002/sse");
+                    setTimeout(() => process.exit(1), 10);
+                    options.helpRequested = true;
+                    return options;
+                }
+                try {
+                    const parsedSseUrl = new URL(sseUrlValue);
+                    // Validate protocol is HTTP or HTTPS (reject file://, ftp://, etc.)
+                    if (parsedSseUrl.protocol !== "http:" &&
+                        parsedSseUrl.protocol !== "https:") {
+                        console.error(`Error: --sse requires HTTP or HTTPS URL, got: ${parsedSseUrl.protocol}`);
+                        console.error("  Expected format: http://hostname:port/path or https://hostname:port/path");
+                        setTimeout(() => process.exit(1), 10);
+                        options.helpRequested = true;
+                        return options;
+                    }
+                    options.sseUrl = sseUrlValue;
+                }
+                catch {
+                    console.error(`Error: Invalid URL for --sse: ${sseUrlValue}`);
+                    console.error("  Expected format: http://hostname:port/path or https://hostname:port/path");
+                    setTimeout(() => process.exit(1), 10);
+                    options.helpRequested = true;
+                    return options;
+                }
+                break;
+            }
+            case "--module":
+            case "-m": {
+                // Issue #184: Single module execution (bypasses orchestrator)
+                const moduleValue = args[++i];
+                if (!moduleValue || moduleValue.startsWith("-")) {
+                    console.error("Error: --module requires a module name");
+                    console.error(`  Valid modules: ${VALID_MODULE_NAMES.join(", ")}`);
+                    setTimeout(() => process.exit(1), 10);
+                    options.helpRequested = true;
+                    return options;
+                }
+                // Validate the module name
+                const validated = validateModuleNames(moduleValue, "--module");
+                if (validated.length === 0) {
+                    options.helpRequested = true;
+                    return options;
+                }
+                // Only accept a single module (first one if multiple provided)
+                options.singleModule = validated[0];
+                break;
+            }
             case "--conformance":
                 // Enable official MCP conformance tests (requires HTTP/SSE transport with serverUrl)
                 options.conformanceEnabled = true;
@@ -326,6 +409,32 @@ export function parseArgs(argv) {
         options.helpRequested = true;
         return options;
     }
+    // Validate mutual exclusivity of --module with orchestrator options (Issue #184)
+    if (options.singleModule &&
+        (options.skipModules?.length ||
+            options.onlyModules?.length ||
+            options.profile)) {
+        console.error("Error: --module cannot be used with --skip-modules, --only-modules, or --profile");
+        console.error("  Use --module for single-module runs, or the other flags for orchestrated runs");
+        setTimeout(() => process.exit(1), 10);
+        options.helpRequested = true;
+        return options;
+    }
+    // Validate mutual exclusivity of --http, --sse, and --config
+    if ((options.httpUrl || options.sseUrl) && options.serverConfigPath) {
+        console.error("Error: --http/--sse cannot be used with --config (they are mutually exclusive)");
+        console.error("  Use --http or --sse for direct URL, or --config for JSON file");
+        setTimeout(() => process.exit(1), 10);
+        options.helpRequested = true;
+        return options;
+    }
+    if (options.httpUrl && options.sseUrl) {
+        console.error("Error: --http and --sse are mutually exclusive");
+        console.error("  Use --http for HTTP transport or --sse for SSE transport");
+        setTimeout(() => process.exit(1), 10);
+        options.helpRequested = true;
+        return options;
+    }
     if (!options.serverName) {
         console.error("Error: --server is required");
         printHelp();
@@ -379,6 +488,8 @@ Run comprehensive MCP server assessment with 16 assessor modules organized in 4
 Options:
   --server, -s <name>    Server name (required, or pass as first positional arg)
   --config, -c <path>    Path to server config JSON
+  --http <url>           Use HTTP transport with specified URL (no config file needed)
+  --sse <url>            Use SSE transport with specified URL (no config file needed)
   --output, -o <path>    Output path (default: /tmp/inspector-full-assessment-<server>.<ext>)
   --source <path>        Source code path for deep analysis (AUP, portability, etc.)
   --debug-source         Enable debug logging for source file loading (Issue #151)
@@ -398,7 +509,7 @@ Options:
   --mcp-auditor-url <url>  mcp-auditor URL for HTTP transport (default: http://localhost:8085)
   --full                 Enable all assessment modules (default)
   --profile <name>       Use predefined module profile (quick, security, compliance, full)
-  --temporal-invocations <n>  Number of invocations per tool for rug pull detection (default: 25)
+  --temporal-invocations <n>  Number of invocations per tool for rug pull detection (default: 3)
   --skip-temporal        Skip temporal/rug pull testing (faster assessment)
   --conformance          Enable official MCP conformance tests (experimental, requires HTTP/SSE transport)
   --output-format <fmt>  Output format: full (default), tiered, summary-only
@@ -409,6 +520,8 @@ Options:
   --stage-b-verbose      Enable Stage B enrichment for Claude semantic analysis
                          Adds evidence samples, payload correlations, and confidence
                          breakdowns to tiered output (Tier 2 + Tier 3)
+  --module, -m <name>    Run single module directly (bypasses orchestrator for faster execution)
+                         Mutually exclusive with --skip-modules, --only-modules, --profile
   --skip-modules <list>  Skip specific modules (comma-separated)
   --only-modules <list>  Run only specific modules (comma-separated)
   --json                 Output only JSON path (no console summary)
@@ -426,7 +539,8 @@ Environment Variables:
 
 ${getProfileHelpText()}
 Module Selection:
-  --profile, --skip-modules, and --only-modules are mutually exclusive.
+  --module, --profile, --skip-modules, and --only-modules are mutually exclusive.
+  Use --module for single-module runs (fastest, bypasses orchestrator).
   Use --profile for common assessment scenarios.
   Use --skip-modules for custom runs by disabling expensive modules.
   Use --only-modules to focus on specific areas (e.g., tool annotation PRs).
@@ -468,13 +582,27 @@ Module Tiers (16 total):
     • Portability        - Cross-platform compatibility
     • External API       - External service detection
 
+Transport Options:
+  --config, --http, and --sse are mutually exclusive.
+  Use --http or --sse for quick testing without a config file.
+  Use --config for complex setups (STDIO, env vars, etc.).
+
 Examples:
+  # Quick HTTP/SSE testing (no config file needed):
+  mcp-assess-full my-server --http http://localhost:10900/mcp
+  mcp-assess-full my-server --sse http://localhost:9002/sse
+
   # Profile-based (recommended):
   mcp-assess-full my-server --profile quick         # CI/CD fast check (~30s)
   mcp-assess-full my-server --profile security      # Security audit (~2-3min)
   mcp-assess-full my-server --profile compliance    # Directory submission (~5min)
   mcp-assess-full my-server --profile full          # Comprehensive audit (~10-15min)
 
+  # Single module (fastest - bypasses orchestrator):
+  mcp-assess-full my-server --http http://localhost:10900/mcp --module toolAnnotations
+  mcp-assess-full my-server --http http://localhost:10900/mcp --module functionality
+  mcp-assess-full my-server --http http://localhost:10900/mcp --module security
+
   # Custom module selection:
   mcp-assess-full my-server --skip-modules temporal,resources  # Skip expensive modules
   mcp-assess-full my-server --only-modules functionality,toolAnnotations  # Annotation PR review

package/build/lib/result-output.js

@@ -305,3 +305,133 @@ export function displaySummary(results) {
     }
     console.log("\n" + "=".repeat(70));
 }
+// ============================================================================
+// Single Module Output (Issue #184)
+// ============================================================================
+/**
+ * Save single module results to file.
+ *
+ * @param serverName - Server name
+ * @param moduleName - Module ID that was executed
+ * @param result - Single module result
+ * @param options - Assessment options
+ * @returns Path to output file
+ */
+export function saveSingleModuleResults(serverName, moduleName, result, options) {
+    const defaultPath = `/tmp/inspector-${moduleName}-${serverName}.json`;
+    const finalPath = options.outputPath || defaultPath;
+    fs.writeFileSync(finalPath, JSON.stringify(result, null, 2));
+    return finalPath;
+}
+/**
+ * Display single module summary to console.
+ *
+ * @param result - Single module result
+ */
+export function displaySingleModuleSummary(result) {
+    const statusIcon = result.status === "PASS"
+        ? "✅"
+        : result.status === "FAIL"
+            ? "❌"
+            : result.status === "PARTIAL"
+                ? "⚠️"
+                : "❓";
+    console.log("\n" + "=".repeat(60));
+    console.log(`MODULE: ${result.displayName.toUpperCase()}`);
+    console.log("=".repeat(60));
+    console.log(`Server: ${result.serverName}`);
+    console.log(`Status: ${statusIcon} ${result.status}`);
+    console.log(`Estimated Tests: ${result.estimatedTestCount}`);
+    console.log(`Execution Time: ${result.executionTime}ms`);
+    console.log("=".repeat(60));
+    // Display module-specific highlights based on result type
+    displayModuleHighlights(result);
+}
+/**
+ * Display module-specific highlights from the result.
+ */
+function displayModuleHighlights(result) {
+    const r = result.result;
+    if (!r)
+        return;
+    // Security module
+    if (result.module === "security") {
+        const vulnCount = Array.isArray(r.vulnerabilities)
+            ? r.vulnerabilities.length
+            : 0;
+        if (vulnCount > 0) {
+            console.log(`\n🔒 VULNERABILITIES FOUND: ${vulnCount}`);
+            const vulns = r.vulnerabilities;
+            for (const vuln of vulns.slice(0, 5)) {
+                console.log(`   • ${vuln.toolName || "unknown"}: ${vuln.testName || "unknown"} (${vuln.riskLevel || "unknown"})`);
+            }
+            if (vulnCount > 5) {
+                console.log(`   ... and ${vulnCount - 5} more`);
+            }
+        }
+        else {
+            console.log("\n✅ No vulnerabilities detected");
+        }
+    }
+    // Functionality module
+    if (result.module === "functionality") {
+        const working = r.workingTools;
+        const broken = r.brokenTools;
+        if (typeof working === "number" || typeof broken === "number") {
+            console.log(`\n📊 TOOL STATUS: ${working || 0} working, ${Array.isArray(broken) ? broken.length : 0} broken`);
+        }
+    }
+    // Tool Annotations module
+    if (result.module === "toolAnnotations") {
+        const missing = r.missingAnnotationsCount;
+        const misaligned = r.misalignedAnnotationsCount;
+        const annotated = r.annotatedCount;
+        console.log(`\n🏷️  ANNOTATION STATUS:`);
+        if (typeof annotated === "number") {
+            console.log(`   Annotated tools: ${annotated}`);
+        }
+        if (typeof missing === "number" && missing > 0) {
+            console.log(`   ⚠️  Missing annotations: ${missing}`);
+        }
+        if (typeof misaligned === "number" && misaligned > 0) {
+            console.log(`   ⚠️  Misaligned annotations: ${misaligned}`);
+        }
+    }
+    // Error Handling module
+    if (result.module === "errorHandling") {
+        const metrics = r.metrics;
+        if (metrics) {
+            console.log(`\n🛡️  ERROR HANDLING METRICS:`);
+            if (typeof metrics.invalidParamHandledCorrectly === "number") {
+                console.log(`   Invalid param handling: ${metrics.invalidParamHandledCorrectly}%`);
+            }
+            if (typeof metrics.missingParamHandledCorrectly === "number") {
+                console.log(`   Missing param handling: ${metrics.missingParamHandledCorrectly}%`);
+            }
+        }
+    }
+    // AUP Compliance module
+    if (result.module === "aupCompliance") {
+        const violations = r.violations;
+        if (Array.isArray(violations) && violations.length > 0) {
+            const critical = violations.filter((v) => v.severity === "CRITICAL");
+            console.log(`\n⚖️  AUP FINDINGS:`);
+            console.log(`   Total flagged: ${violations.length}`);
+            if (critical.length > 0) {
+                console.log(`   🚨 CRITICAL violations: ${critical.length}`);
+            }
+        }
+    }
+    // Temporal module
+    if (result.module === "temporal") {
+        const overallRisk = r.overallRisk;
+        const detectedChanges = r.detectedChanges;
+        console.log(`\n⏱️  TEMPORAL ANALYSIS:`);
+        if (typeof overallRisk === "string") {
+            console.log(`   Overall Risk: ${overallRisk}`);
+        }
+        if (typeof detectedChanges === "number") {
+            console.log(`   Detected Changes: ${detectedChanges}`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bryan-thompson/inspector-assessment-cli",
-  "version": "1.38.3",
+  "version": "1.40.0",
   "description": "CLI for the Enhanced MCP Inspector with assessment capabilities",
   "license": "MIT",
   "author": "Bryan Thompson <bryan@triepod.ai>",