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

package/build/lib/assessment-runner/source-loader.js

@@ -0,0 +1,139 @@
+/**
+ * Source File Loading
+ *
+ * Handles recursive source file discovery with gitignore support.
+ *
+ * @module cli/lib/assessment-runner/source-loader
+ */
+import * as fs from "fs";
+import * as path from "path";
+/** Maximum file size (in characters) to include in source code analysis */
+const MAX_SOURCE_FILE_SIZE = 100_000;
+/**
+ * Load optional files from source code path
+ *
+ * @param sourcePath - Path to source code directory
+ * @returns Object containing loaded source files
+ */
+export function loadSourceFiles(sourcePath) {
+    const result = {};
+    // Search for README in source directory and parent directories (up to 3 levels)
+    // This handles cases where --source points to a subdirectory but README is at repo root
+    const readmePaths = ["README.md", "readme.md", "Readme.md"];
+    let readmeFound = false;
+    // First try the source directory itself
+    for (const readmePath of readmePaths) {
+        const fullPath = path.join(sourcePath, readmePath);
+        if (fs.existsSync(fullPath)) {
+            result.readmeContent = fs.readFileSync(fullPath, "utf-8");
+            readmeFound = true;
+            break;
+        }
+    }
+    // If not found, search parent directories (up to 3 levels)
+    if (!readmeFound) {
+        let currentDir = sourcePath;
+        for (let i = 0; i < 3; i++) {
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir)
+                break; // Reached filesystem root
+            for (const readmePath of readmePaths) {
+                const fullPath = path.join(parentDir, readmePath);
+                if (fs.existsSync(fullPath)) {
+                    result.readmeContent = fs.readFileSync(fullPath, "utf-8");
+                    readmeFound = true;
+                    break;
+                }
+            }
+            if (readmeFound)
+                break;
+            currentDir = parentDir;
+        }
+    }
+    const packagePath = path.join(sourcePath, "package.json");
+    if (fs.existsSync(packagePath)) {
+        result.packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+    }
+    const manifestPath = path.join(sourcePath, "manifest.json");
+    if (fs.existsSync(manifestPath)) {
+        result.manifestRaw = fs.readFileSync(manifestPath, "utf-8");
+        try {
+            result.manifestJson = JSON.parse(result.manifestRaw);
+        }
+        catch {
+            console.warn("[Assessment] Failed to parse manifest.json");
+        }
+    }
+    result.sourceCodeFiles = new Map();
+    // Include config files for portability analysis
+    const sourceExtensions = [
+        ".ts",
+        ".js",
+        ".py",
+        ".go",
+        ".rs",
+        ".json",
+        ".sh",
+        ".yaml",
+        ".yml",
+    ];
+    // Parse .gitignore patterns
+    const gitignorePatterns = [];
+    const gitignorePath = path.join(sourcePath, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+        const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+        for (const line of gitignoreContent.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            // Convert gitignore pattern to regex
+            const pattern = trimmed
+                .replace(/\./g, "\\.")
+                .replace(/\*\*/g, ".*")
+                .replace(/\*/g, "[^/]*")
+                .replace(/\?/g, ".");
+            try {
+                gitignorePatterns.push(new RegExp(pattern));
+            }
+            catch {
+                // Skip invalid patterns
+            }
+        }
+    }
+    const isGitignored = (relativePath) => {
+        return gitignorePatterns.some((pattern) => pattern.test(relativePath));
+    };
+    const loadSourceDir = (dir, prefix = "") => {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || entry.name === "node_modules")
+                continue;
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            // Skip gitignored files
+            if (isGitignored(relativePath))
+                continue;
+            if (entry.isDirectory()) {
+                loadSourceDir(fullPath, relativePath);
+            }
+            else if (sourceExtensions.some((ext) => entry.name.endsWith(ext))) {
+                try {
+                    const content = fs.readFileSync(fullPath, "utf-8");
+                    if (content.length < MAX_SOURCE_FILE_SIZE) {
+                        result.sourceCodeFiles.set(relativePath, content);
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+        }
+    };
+    try {
+        loadSourceDir(sourcePath);
+    }
+    catch (e) {
+        console.warn("[Assessment] Could not load source files:", e);
+    }
+    return result;
+}

package/build/lib/assessment-runner/tool-wrapper.js

@@ -0,0 +1,40 @@
+/**
+ * Tool Call Wrapper
+ *
+ * Creates a wrapper around MCP client.callTool() for assessment context.
+ *
+ * @module cli/lib/assessment-runner/tool-wrapper
+ */
+/**
+ * Create callTool wrapper for assessment context
+ *
+ * @param client - Connected MCP client
+ * @returns Wrapped callTool function
+ */
+export function createCallToolWrapper(client) {
+    return async (name, params) => {
+        try {
+            const response = await client.callTool({
+                name,
+                arguments: params,
+            });
+            return {
+                content: response.content,
+                isError: response.isError || false,
+                structuredContent: response
+                    .structuredContent,
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Assessment Runner Types
+ *
+ * Shared type definitions for the assessment-runner module.
+ *
+ * @module cli/lib/assessment-runner/types
+ */
+export {};