@bryan-thompson/inspector-assessment-cli 1.13.1 → 1.14.0

package/build/assess-full.js

@@ -22,6 +22,9 @@ import { DEFAULT_ASSESSMENT_CONFIG, } from "../../client/lib/lib/assessmentTypes
 import { FULL_CLAUDE_CODE_CONFIG } from "../../client/lib/services/assessment/lib/claudeCodeBridge.js";
 import { createFormatter, } from "../../client/lib/lib/reportFormatters/index.js";
 import { generatePolicyComplianceReport } from "../../client/lib/services/assessment/PolicyComplianceGenerator.js";
+import { compareAssessments } from "../../client/lib/lib/assessmentDiffer.js";
+import { formatDiffAsMarkdown } from "../../client/lib/lib/reportFormatters/DiffReportFormatter.js";
+import { AssessmentStateManager } from "./assessmentState.js";
 /**
  * Load server configuration from Claude Code's MCP settings
  */
@@ -296,6 +299,34 @@ async function runFullAssessment(options) {
     if (!options.jsonOnly) {
         console.log(`🔧 Found ${tools.length} tool${tools.length !== 1 ? "s" : ""}`);
     }
+    // State management for resumable assessments
+    const stateManager = new AssessmentStateManager(options.serverName);
+    if (stateManager.exists() && !options.noResume) {
+        const summary = stateManager.getSummary();
+        if (summary) {
+            if (!options.jsonOnly) {
+                console.log(`\n📋 Found interrupted session from ${summary.startedAt}`);
+                console.log(`   Completed modules: ${summary.completedModules.length > 0 ? summary.completedModules.join(", ") : "none"}`);
+            }
+            if (options.resume) {
+                if (!options.jsonOnly) {
+                    console.log("   Resuming from previous state...");
+                }
+                // Will use partial results later
+            }
+            else if (!options.jsonOnly) {
+                console.log("   Use --resume to continue or --no-resume to start fresh");
+                // Clear state and start fresh by default
+                stateManager.clear();
+            }
+        }
+    }
+    else if (options.noResume && stateManager.exists()) {
+        stateManager.clear();
+        if (!options.jsonOnly) {
+            console.log("🗑️  Cleared previous assessment state");
+        }
+    }
     // Pre-flight validation checks
     if (options.preflightOnly) {
         const preflightResult = {
@@ -561,6 +592,18 @@ function parseArgs() {
             case "--preflight":
                 options.preflightOnly = true;
                 break;
+            case "--compare":
+                options.comparePath = args[++i];
+                break;
+            case "--diff-only":
+                options.diffOnly = true;
+                break;
+            case "--resume":
+                options.resume = true;
+                break;
+            case "--no-resume":
+                options.noResume = true;
+                break;
             case "--help":
             case "-h":
                 printHelp();
@@ -608,6 +651,10 @@ Options:
   --format, -f <type>    Output format: json (default) or markdown
   --include-policy       Include policy compliance mapping in report (30 requirements)
   --preflight            Run quick validation only (tools exist, manifest valid, server responds)
+  --compare <path>       Compare current assessment against baseline JSON file
+  --diff-only            Output only the comparison diff (requires --compare)
+  --resume               Resume from previous interrupted assessment
+  --no-resume            Force fresh start, clear any existing state
   --claude-enabled       Enable Claude Code integration for intelligent analysis
   --full                 Enable all assessment modules (default)
   --json                 Output only JSON path (no console summary)
@@ -632,6 +679,8 @@ Examples:
   mcp-assess-full --server broken-mcp --claude-enabled
   mcp-assess-full --server my-server --source ./my-server --output ./results.json
   mcp-assess-full --server my-server --format markdown --include-policy
+  mcp-assess-full --server my-server --compare ./baseline.json
+  mcp-assess-full --server my-server --compare ./baseline.json --diff-only --format markdown
   `);
 }
 /**
@@ -648,6 +697,60 @@ async function main() {
         if (options.preflightOnly) {
             return;
         }
+        // Handle comparison mode
+        if (options.comparePath) {
+            if (!fs.existsSync(options.comparePath)) {
+                console.error(`Error: Baseline file not found: ${options.comparePath}`);
+                setTimeout(() => process.exit(1), 10);
+                return;
+            }
+            const baselineData = JSON.parse(fs.readFileSync(options.comparePath, "utf-8"));
+            const baseline = baselineData.functionality && baselineData.security
+                ? baselineData
+                : baselineData;
+            const diff = compareAssessments(baseline, results);
+            if (options.diffOnly) {
+                // Only output diff, not full assessment
+                if (options.format === "markdown") {
+                    const diffPath = options.outputPath ||
+                        `/tmp/inspector-diff-${options.serverName}.md`;
+                    fs.writeFileSync(diffPath, formatDiffAsMarkdown(diff));
+                    console.log(diffPath);
+                }
+                else {
+                    const diffPath = options.outputPath ||
+                        `/tmp/inspector-diff-${options.serverName}.json`;
+                    fs.writeFileSync(diffPath, JSON.stringify(diff, null, 2));
+                    console.log(diffPath);
+                }
+                const exitCode = diff.summary.overallChange === "regressed" ? 1 : 0;
+                setTimeout(() => process.exit(exitCode), 10);
+                return;
+            }
+            // Include diff in output alongside full assessment
+            if (!options.jsonOnly) {
+                console.log("\n" + "=".repeat(70));
+                console.log("VERSION COMPARISON");
+                console.log("=".repeat(70));
+                console.log(`Baseline: ${diff.baseline.version || "N/A"} (${diff.baseline.date})`);
+                console.log(`Current:  ${diff.current.version || "N/A"} (${diff.current.date})`);
+                console.log(`Overall Change: ${diff.summary.overallChange.toUpperCase()}`);
+                console.log(`Modules Improved: ${diff.summary.modulesImproved}`);
+                console.log(`Modules Regressed: ${diff.summary.modulesRegressed}`);
+                if (diff.securityDelta.newVulnerabilities.length > 0) {
+                    console.log(`\n⚠️  NEW VULNERABILITIES: ${diff.securityDelta.newVulnerabilities.length}`);
+                }
+                if (diff.securityDelta.fixedVulnerabilities.length > 0) {
+                    console.log(`✅ FIXED VULNERABILITIES: ${diff.securityDelta.fixedVulnerabilities.length}`);
+                }
+                if (diff.functionalityDelta.newBrokenTools.length > 0) {
+                    console.log(`❌ NEW BROKEN TOOLS: ${diff.functionalityDelta.newBrokenTools.length}`);
+                }
+                if (diff.functionalityDelta.fixedTools.length > 0) {
+                    console.log(`✅ FIXED TOOLS: ${diff.functionalityDelta.fixedTools.length}`);
+                }
+            }
+        }
         if (!options.jsonOnly) {
             displaySummary(results);
         }

package/build/assessmentState.js

@@ -0,0 +1,168 @@
+/**
+ * Assessment State Manager
+ * File-based state management for resumable assessments.
+ *
+ * Purpose:
+ * - Allow long-running assessments to be paused and resumed
+ * - Checkpoint after each module completes
+ * - Recover from interruptions
+ */
+import * as fs from "fs";
+const STATE_VERSION = "1.0";
+/**
+ * Manages assessment state persistence for resumable runs
+ */
+export class AssessmentStateManager {
+    statePath;
+    constructor(serverName, stateDir = "/tmp") {
+        this.statePath = `${stateDir}/inspector-assessment-state-${serverName}.json`;
+    }
+    /**
+     * Check if a previous state exists
+     */
+    exists() {
+        return fs.existsSync(this.statePath);
+    }
+    /**
+     * Load state from disk
+     */
+    load() {
+        if (!this.exists())
+            return null;
+        try {
+            const data = fs.readFileSync(this.statePath, "utf-8");
+            const state = JSON.parse(data);
+            // Validate state version
+            if (state.version !== STATE_VERSION) {
+                console.warn(`[StateManager] State version mismatch: ${state.version} vs ${STATE_VERSION}, clearing`);
+                this.clear();
+                return null;
+            }
+            return state;
+        }
+        catch (error) {
+            console.warn("[StateManager] Failed to load state:", error);
+            return null;
+        }
+    }
+    /**
+     * Create a new state for a fresh assessment
+     */
+    create(serverName, config, toolsDiscovered) {
+        const state = {
+            sessionId: this.generateSessionId(),
+            serverName,
+            startedAt: new Date().toISOString(),
+            lastUpdatedAt: new Date().toISOString(),
+            config,
+            completedModules: [],
+            currentModule: null,
+            partialResults: {
+                serverName,
+                assessmentDate: new Date().toISOString(),
+                assessorVersion: "1.13.1", // Will be updated from package.json
+            },
+            toolsDiscovered,
+            version: STATE_VERSION,
+        };
+        this.save(state);
+        return state;
+    }
+    /**
+     * Save state to disk
+     */
+    save(state) {
+        state.lastUpdatedAt = new Date().toISOString();
+        fs.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+    }
+    /**
+     * Mark a module as starting
+     */
+    startModule(moduleName) {
+        const state = this.load();
+        if (state) {
+            state.currentModule = moduleName;
+            this.save(state);
+        }
+    }
+    /**
+     * Mark a module as complete and save its result
+     */
+    completeModule(moduleName, result) {
+        const state = this.load();
+        if (state) {
+            state.completedModules.push(moduleName);
+            state.currentModule = null;
+            // Store the result in partialResults
+            state.partialResults[moduleName] = result;
+            this.save(state);
+        }
+    }
+    /**
+     * Get list of completed modules
+     */
+    getCompletedModules() {
+        const state = this.load();
+        return state?.completedModules || [];
+    }
+    /**
+     * Check if a module was already completed
+     */
+    isModuleCompleted(moduleName) {
+        const state = this.load();
+        return state?.completedModules.includes(moduleName) || false;
+    }
+    /**
+     * Get partial results from previous run
+     */
+    getPartialResults() {
+        const state = this.load();
+        return state?.partialResults || null;
+    }
+    /**
+     * Clear state (delete state file)
+     */
+    clear() {
+        if (this.exists()) {
+            try {
+                fs.unlinkSync(this.statePath);
+            }
+            catch {
+                // Ignore errors on cleanup
+            }
+        }
+    }
+    /**
+     * Get state file path
+     */
+    getStatePath() {
+        return this.statePath;
+    }
+    /**
+     * Get state summary for display
+     */
+    getSummary() {
+        const state = this.load();
+        if (!state)
+            return null;
+        return {
+            sessionId: state.sessionId,
+            startedAt: state.startedAt,
+            completedModules: state.completedModules,
+            currentModule: state.currentModule,
+            toolsDiscovered: state.toolsDiscovered,
+        };
+    }
+    /**
+     * Generate unique session ID
+     */
+    generateSessionId() {
+        return `assess-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    }
+}
+/**
+ * Factory function to create state manager
+ */
+export function createStateManager(serverName, stateDir) {
+    return new AssessmentStateManager(serverName, stateDir);
+}

package/package.json

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