@bryan-thompson/inspector-assessment-cli 1.26.6 → 1.26.7

package/build/__tests__/assessment-runner/source-loader.test.js

@@ -0,0 +1,341 @@
+/**
+ * Source Loader Unit Tests
+ *
+ * Tests for loadSourceFiles() that loads source files with gitignore support.
+ */
+import { jest, describe, it, expect, beforeEach } from "@jest/globals";
+import * as path from "path";
+// Mock fs module
+jest.unstable_mockModule("fs", () => ({
+    existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+    readdirSync: jest.fn(),
+}));
+// Import after mocking
+const fs = await import("fs");
+const { loadSourceFiles } = await import("../../lib/assessment-runner/source-loader.js");
+// Helper to create mock Dirent objects
+function createDirent(name, isDirectory) {
+    return {
+        name,
+        isDirectory: () => isDirectory,
+        isFile: () => !isDirectory,
+        isBlockDevice: () => false,
+        isCharacterDevice: () => false,
+        isSymbolicLink: () => false,
+        isFIFO: () => false,
+        isSocket: () => false,
+        parentPath: "",
+        path: "",
+    };
+}
+describe("loadSourceFiles", () => {
+    const mockExistsSync = fs.existsSync;
+    const mockReadFileSync = fs.readFileSync;
+    const mockReaddirSync = fs.readdirSync;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExistsSync.mockReturnValue(false);
+        mockReaddirSync.mockReturnValue([]);
+    });
+    describe("README discovery", () => {
+        it("should find README.md in source directory", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "README.md"));
+            mockReadFileSync.mockReturnValue("# Project README");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("# Project README");
+        });
+        it("should find readme.md with lowercase", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "readme.md"));
+            mockReadFileSync.mockReturnValue("# Lowercase README");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("# Lowercase README");
+        });
+        it("should find Readme.md with mixed case", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "Readme.md"));
+            mockReadFileSync.mockReturnValue("# Mixed Case README");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("# Mixed Case README");
+        });
+        it("should search parent directories for README (up to 3 levels)", () => {
+            const sourcePath = "/project/packages/core/src";
+            // README is in /project (3 levels up)
+            mockExistsSync.mockImplementation((p) => p === "/project/README.md");
+            mockReadFileSync.mockReturnValue("# Root README");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBe("# Root README");
+        });
+        it("should not search more than 3 levels up", () => {
+            const sourcePath = "/a/b/c/d/e";
+            // README is in /a (4 levels up) - should not be found
+            mockExistsSync.mockReturnValue(false);
+            const result = loadSourceFiles(sourcePath);
+            expect(result.readmeContent).toBeUndefined();
+        });
+    });
+    describe("package.json parsing", () => {
+        it("should parse package.json when present", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "package.json"));
+            mockReadFileSync.mockReturnValue(JSON.stringify({
+                name: "test-package",
+                version: "1.0.0",
+            }));
+            const result = loadSourceFiles(sourcePath);
+            expect(result.packageJson).toEqual({
+                name: "test-package",
+                version: "1.0.0",
+            });
+        });
+        it("should not set packageJson when file does not exist", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            const result = loadSourceFiles(sourcePath);
+            expect(result.packageJson).toBeUndefined();
+        });
+    });
+    describe("manifest.json parsing", () => {
+        it("should parse manifest.json when present", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "manifest.json"));
+            const manifestContent = JSON.stringify({
+                name: "test-server",
+                tools: [],
+            });
+            mockReadFileSync.mockReturnValue(manifestContent);
+            const result = loadSourceFiles(sourcePath);
+            expect(result.manifestJson).toEqual({
+                name: "test-server",
+                tools: [],
+            });
+            expect(result.manifestRaw).toBe(manifestContent);
+        });
+        it("should set manifestRaw but warn on invalid JSON manifest", () => {
+            const sourcePath = "/project";
+            const consoleSpy = jest
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, "manifest.json"));
+            mockReadFileSync.mockReturnValue("{ invalid json }");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.manifestRaw).toBe("{ invalid json }");
+            expect(result.manifestJson).toBeUndefined();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to parse manifest.json"));
+            consoleSpy.mockRestore();
+        });
+    });
+    describe("source file collection", () => {
+        it("should collect source files with supported extensions", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockReturnValue([
+                createDirent("index.ts", false),
+                createDirent("utils.js", false),
+                createDirent("config.json", false),
+                createDirent("setup.sh", false),
+            ]);
+            mockReadFileSync.mockImplementation((p) => {
+                if (p.endsWith(".ts"))
+                    return "const x = 1;";
+                if (p.endsWith(".js"))
+                    return "var y = 2;";
+                if (p.endsWith(".json"))
+                    return "{}";
+                if (p.endsWith(".sh"))
+                    return "#!/bin/bash";
+                return "";
+            });
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.size).toBe(4);
+            expect(result.sourceCodeFiles?.has("index.ts")).toBe(true);
+            expect(result.sourceCodeFiles?.has("utils.js")).toBe(true);
+            expect(result.sourceCodeFiles?.has("config.json")).toBe(true);
+            expect(result.sourceCodeFiles?.has("setup.sh")).toBe(true);
+        });
+        it("should recursively load files from subdirectories", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockImplementation((dir) => {
+                if (dir === sourcePath) {
+                    return [createDirent("src", true), createDirent("index.ts", false)];
+                }
+                if (dir === path.join(sourcePath, "src")) {
+                    return [createDirent("main.ts", false)];
+                }
+                return [];
+            });
+            mockReadFileSync.mockReturnValue("code");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("index.ts")).toBe(true);
+            expect(result.sourceCodeFiles?.has("src/main.ts")).toBe(true);
+        });
+        it("should enforce 100KB file size limit", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockReturnValue([
+                createDirent("small.ts", false),
+                createDirent("large.ts", false),
+            ]);
+            mockReadFileSync.mockImplementation((p) => {
+                if (p.includes("small"))
+                    return "small content";
+                if (p.includes("large"))
+                    return "x".repeat(100_001); // > 100KB
+                return "";
+            });
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("small.ts")).toBe(true);
+            expect(result.sourceCodeFiles?.has("large.ts")).toBe(false);
+        });
+        it("should skip dotfiles and directories", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockReturnValue([
+                createDirent(".git", true),
+                createDirent(".eslintrc.js", false),
+                createDirent("src.ts", false),
+            ]);
+            mockReadFileSync.mockReturnValue("code");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("src.ts")).toBe(true);
+            expect(result.sourceCodeFiles?.has(".eslintrc.js")).toBe(false);
+            expect(result.sourceCodeFiles?.has(".git")).toBe(false);
+        });
+        it("should skip node_modules directory", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockImplementation((dir) => {
+                if (dir === sourcePath) {
+                    return [
+                        createDirent("node_modules", true),
+                        createDirent("src", true),
+                    ];
+                }
+                if (dir === path.join(sourcePath, "src")) {
+                    return [createDirent("index.ts", false)];
+                }
+                return [];
+            });
+            mockReadFileSync.mockReturnValue("code");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("src/index.ts")).toBe(true);
+            // node_modules should be skipped entirely
+        });
+    });
+    describe("gitignore support", () => {
+        it("should respect .gitignore patterns", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, ".gitignore"));
+            mockReadFileSync.mockImplementation((p) => {
+                if (p.endsWith(".gitignore")) {
+                    return "dist/\n*.log\nbuild/**";
+                }
+                return "code";
+            });
+            mockReaddirSync.mockReturnValue([
+                createDirent("index.ts", false),
+                createDirent("debug.log", false),
+                createDirent("dist", true),
+            ]);
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("index.ts")).toBe(true);
+            expect(result.sourceCodeFiles?.has("debug.log")).toBe(false);
+        });
+        it("should handle missing .gitignore gracefully", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockReturnValue([createDirent("index.ts", false)]);
+            mockReadFileSync.mockReturnValue("code");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("index.ts")).toBe(true);
+        });
+        it("should ignore comments and empty lines in .gitignore", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockImplementation((p) => p === path.join(sourcePath, ".gitignore"));
+            mockReadFileSync.mockImplementation((p) => {
+                if (p.endsWith(".gitignore")) {
+                    return "# comment\n\n*.log\n   \n# another comment";
+                }
+                return "code";
+            });
+            mockReaddirSync.mockReturnValue([
+                createDirent("index.ts", false),
+                createDirent("debug.log", false),
+            ]);
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("index.ts")).toBe(true);
+            expect(result.sourceCodeFiles?.has("debug.log")).toBe(false);
+        });
+    });
+    describe("error handling", () => {
+        it("should return empty sourceCodeFiles when directory read fails", () => {
+            const sourcePath = "/project";
+            const consoleSpy = jest
+                .spyOn(console, "warn")
+                .mockImplementation(() => { });
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockImplementation(() => {
+                throw new Error("Permission denied");
+            });
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.size).toBe(0);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Could not load source files"), expect.any(Error));
+            consoleSpy.mockRestore();
+        });
+        it("should skip unreadable files silently", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockReturnValue([
+                createDirent("readable.ts", false),
+                createDirent("unreadable.ts", false),
+            ]);
+            mockReadFileSync.mockImplementation((p) => {
+                if (p.includes("unreadable")) {
+                    throw new Error("Permission denied");
+                }
+                return "code";
+            });
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.has("readable.ts")).toBe(true);
+            expect(result.sourceCodeFiles?.has("unreadable.ts")).toBe(false);
+        });
+    });
+    describe("supported file extensions", () => {
+        it("should support all defined extensions", () => {
+            const sourcePath = "/project";
+            const extensions = [
+                ".ts",
+                ".js",
+                ".py",
+                ".go",
+                ".rs",
+                ".json",
+                ".sh",
+                ".yaml",
+                ".yml",
+            ];
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockReturnValue(extensions.map((ext) => createDirent(`file${ext}`, false)));
+            mockReadFileSync.mockReturnValue("content");
+            const result = loadSourceFiles(sourcePath);
+            for (const ext of extensions) {
+                expect(result.sourceCodeFiles?.has(`file${ext}`)).toBe(true);
+            }
+        });
+        it("should not include unsupported file types", () => {
+            const sourcePath = "/project";
+            mockExistsSync.mockReturnValue(false);
+            mockReaddirSync.mockReturnValue([
+                createDirent("image.png", false),
+                createDirent("doc.pdf", false),
+                createDirent("data.csv", false),
+            ]);
+            mockReadFileSync.mockReturnValue("content");
+            const result = loadSourceFiles(sourcePath);
+            expect(result.sourceCodeFiles?.size).toBe(0);
+        });
+    });
+});

package/build/__tests__/assessment-runner/tool-wrapper.test.js

@@ -0,0 +1,114 @@
+/**
+ * Tool Wrapper Unit Tests
+ *
+ * Tests for createCallToolWrapper() that wraps MCP client.callTool().
+ */
+import { jest, describe, it, expect, beforeEach } from "@jest/globals";
+// Import the actual function (no mocking needed for this module)
+import { createCallToolWrapper } from "../../lib/assessment-runner/tool-wrapper.js";
+describe("createCallToolWrapper", () => {
+    let mockClient;
+    let mockCallTool;
+    beforeEach(() => {
+        mockCallTool = jest.fn();
+        mockClient = {
+            callTool: mockCallTool,
+        };
+    });
+    describe("successful tool calls", () => {
+        it("should wrap successful tool response with content array", async () => {
+            mockCallTool.mockResolvedValue({
+                content: [{ type: "text", text: "Hello, World!" }],
+            });
+            const callTool = createCallToolWrapper(mockClient);
+            const result = await callTool("greet", { name: "World" });
+            expect(mockCallTool).toHaveBeenCalledWith({
+                name: "greet",
+                arguments: { name: "World" },
+            });
+            expect(result.content).toEqual([{ type: "text", text: "Hello, World!" }]);
+        });
+        it("should include structuredContent from response when present", async () => {
+            mockCallTool.mockResolvedValue({
+                content: [{ type: "text", text: "result" }],
+                structuredContent: { data: [1, 2, 3] },
+            });
+            const callTool = createCallToolWrapper(mockClient);
+            const result = await callTool("getData", {});
+            expect(result.structuredContent).toEqual({ data: [1, 2, 3] });
+        });
+        it("should set isError false by default", async () => {
+            mockCallTool.mockResolvedValue({
+                content: [{ type: "text", text: "success" }],
+            });
+            const callTool = createCallToolWrapper(mockClient);
+            const result = await callTool("tool", {});
+            expect(result.isError).toBe(false);
+        });
+        it("should preserve isError true when response has error flag", async () => {
+            mockCallTool.mockResolvedValue({
+                content: [{ type: "text", text: "Tool error occurred" }],
+                isError: true,
+            });
+            const callTool = createCallToolWrapper(mockClient);
+            const result = await callTool("failingTool", {});
+            expect(result.isError).toBe(true);
+            expect(result.content).toEqual([
+                { type: "text", text: "Tool error occurred" },
+            ]);
+        });
+    });
+    describe("exception handling", () => {
+        it("should catch exceptions and return error text content", async () => {
+            mockCallTool.mockRejectedValue(new Error("Network timeout"));
+            const callTool = createCallToolWrapper(mockClient);
+            const result = await callTool("networkTool", {});
+            expect(result.content).toEqual([
+                { type: "text", text: "Error: Network timeout" },
+            ]);
+        });
+        it("should set isError true on caught exceptions", async () => {
+            mockCallTool.mockRejectedValue(new Error("Something went wrong"));
+            const callTool = createCallToolWrapper(mockClient);
+            const result = await callTool("brokenTool", {});
+            expect(result.isError).toBe(true);
+        });
+        it("should handle non-Error exceptions", async () => {
+            mockCallTool.mockRejectedValue("String error");
+            const callTool = createCallToolWrapper(mockClient);
+            const result = await callTool("stringErrorTool", {});
+            expect(result.content).toEqual([
+                { type: "text", text: "Error: String error" },
+            ]);
+            expect(result.isError).toBe(true);
+        });
+    });
+    describe("argument passing", () => {
+        it("should pass parameters as arguments to callTool", async () => {
+            mockCallTool.mockResolvedValue({ content: [] });
+            const callTool = createCallToolWrapper(mockClient);
+            await callTool("complexTool", {
+                query: "search term",
+                limit: 10,
+                options: { deep: true },
+            });
+            expect(mockCallTool).toHaveBeenCalledWith({
+                name: "complexTool",
+                arguments: {
+                    query: "search term",
+                    limit: 10,
+                    options: { deep: true },
+                },
+            });
+        });
+        it("should handle empty parameters", async () => {
+            mockCallTool.mockResolvedValue({ content: [] });
+            const callTool = createCallToolWrapper(mockClient);
+            await callTool("noArgsTool", {});
+            expect(mockCallTool).toHaveBeenCalledWith({
+                name: "noArgsTool",
+                arguments: {},
+            });
+        });
+    });
+});

package/build/__tests__/assessment-runner-facade.test.js

@@ -0,0 +1,118 @@
+/**
+ * Assessment Runner Facade Backward Compatibility Tests
+ *
+ * Verifies that the facade pattern maintains backward compatibility
+ * after the modularization in Issue #94.
+ *
+ * @see https://github.com/triepod-ai/inspector-assessment/issues/96
+ */
+import { describe, it, expect } from "@jest/globals";
+// Test named imports (the primary consumer pattern)
+import { loadServerConfig, loadSourceFiles, connectToServer, createCallToolWrapper, buildConfig, runFullAssessment, } from "../lib/assessment-runner.js";
+// Test namespace import
+import * as AssessmentRunner from "../lib/assessment-runner.js";
+describe("Assessment Runner Facade", () => {
+    describe("Function Exports", () => {
+        it("should export loadServerConfig function", () => {
+            expect(typeof loadServerConfig).toBe("function");
+        });
+        it("should export loadSourceFiles function", () => {
+            expect(typeof loadSourceFiles).toBe("function");
+        });
+        it("should export connectToServer function", () => {
+            expect(typeof connectToServer).toBe("function");
+        });
+        it("should export createCallToolWrapper function", () => {
+            expect(typeof createCallToolWrapper).toBe("function");
+        });
+        it("should export buildConfig function", () => {
+            expect(typeof buildConfig).toBe("function");
+        });
+        it("should export runFullAssessment function", () => {
+            expect(typeof runFullAssessment).toBe("function");
+        });
+    });
+    describe("Namespace Import Compatibility", () => {
+        it("should export all functions via namespace import", () => {
+            expect(typeof AssessmentRunner.loadServerConfig).toBe("function");
+            expect(typeof AssessmentRunner.loadSourceFiles).toBe("function");
+            expect(typeof AssessmentRunner.connectToServer).toBe("function");
+            expect(typeof AssessmentRunner.createCallToolWrapper).toBe("function");
+            expect(typeof AssessmentRunner.buildConfig).toBe("function");
+            expect(typeof AssessmentRunner.runFullAssessment).toBe("function");
+        });
+        it("should have consistent function references between import styles", () => {
+            // Verify that named imports and namespace imports reference the same functions
+            expect(loadServerConfig).toBe(AssessmentRunner.loadServerConfig);
+            expect(loadSourceFiles).toBe(AssessmentRunner.loadSourceFiles);
+            expect(connectToServer).toBe(AssessmentRunner.connectToServer);
+            expect(createCallToolWrapper).toBe(AssessmentRunner.createCallToolWrapper);
+            expect(buildConfig).toBe(AssessmentRunner.buildConfig);
+            expect(runFullAssessment).toBe(AssessmentRunner.runFullAssessment);
+        });
+    });
+    describe("Type Exports", () => {
+        it("should export SourceFiles type with expected shape", () => {
+            // TypeScript compile-time check - if this compiles, the type is exported correctly
+            const sourceFiles = {
+                readmeContent: "# Test",
+                packageJson: { name: "test" },
+                manifestJson: undefined,
+                manifestRaw: undefined,
+                sourceCodeFiles: new Map(),
+            };
+            // Runtime verification of the shape
+            expect(sourceFiles).toHaveProperty("readmeContent");
+            expect(sourceFiles).toHaveProperty("packageJson");
+            expect(sourceFiles).toHaveProperty("sourceCodeFiles");
+        });
+        it("should export CallToolFn type", () => {
+            // TypeScript compile-time check - if this compiles, the type is exported correctly
+            const mockCallTool = async (name, params) => {
+                return {
+                    content: [{ type: "text", text: `Called ${name}` }],
+                    isError: false,
+                };
+            };
+            // Verify the function signature works
+            expect(typeof mockCallTool).toBe("function");
+        });
+    });
+    describe("Export Completeness", () => {
+        it("should export exactly 6 functions", () => {
+            const exportedFunctions = Object.entries(AssessmentRunner).filter(([, value]) => typeof value === "function");
+            expect(exportedFunctions.length).toBe(6);
+            expect(exportedFunctions.map(([name]) => name).sort()).toEqual([
+                "buildConfig",
+                "connectToServer",
+                "createCallToolWrapper",
+                "loadServerConfig",
+                "loadSourceFiles",
+                "runFullAssessment",
+            ]);
+        });
+        it("should not have unexpected exports", () => {
+            const allExports = Object.keys(AssessmentRunner);
+            const expectedExports = [
+                "loadServerConfig",
+                "loadSourceFiles",
+                "connectToServer",
+                "createCallToolWrapper",
+                "buildConfig",
+                "runFullAssessment",
+            ];
+            // All exports should be in the expected list
+            for (const exportName of allExports) {
+                expect(expectedExports).toContain(exportName);
+            }
+        });
+    });
+    describe("Consumer Compatibility", () => {
+        it("should support the existing assess-full.ts import pattern", () => {
+            // This is the exact import pattern used in assess-full.ts:18
+            // import { runFullAssessment } from "./lib/assessment-runner.js";
+            expect(runFullAssessment).toBeDefined();
+            expect(typeof runFullAssessment).toBe("function");
+        });
+    });
+});