qa360 2.1.7 → 2.2.0

package/packages/mcp/src/tools/history.ts

@@ -0,0 +1,388 @@
+/**
+ * QA360 History Tools
+ * Manage and query test run history via MCP
+ */
+
+import { EvidenceVault } from 'qa360-core';
+import { createWriteStream, existsSync } from 'fs';
+import { resolve } from 'path';
+import { MCPServerConfig, HistoryListArgs, HistoryGetArgs, HistoryDiffArgs, HistoryTrendArgs, HistoryExportArgs, HistoryGCArgs, HistoryPinArgs } from '../types/index.js';
+import { SecurityManager } from '../security/manager.js';
+import { AuditLogger } from '../security/audit.js';
+
+export class HistoryTools {
+  private config: MCPServerConfig;
+  private security: SecurityManager;
+  private audit: AuditLogger;
+
+  constructor(config: MCPServerConfig, security: SecurityManager, audit: AuditLogger) {
+    this.config = config;
+    this.security = security;
+    this.audit = audit;
+  }
+
+  async execute(toolName: string, args: any): Promise<any> {
+    const vault = await EvidenceVault.open('./.qa360', {
+      enableWAL: true
+    });
+
+    try {
+      switch (toolName) {
+        case 'qa360.history.list':
+          return await this.list(vault, args as HistoryListArgs);
+        case 'qa360.history.get':
+          return await this.get(vault, args as HistoryGetArgs);
+        case 'qa360.history.diff':
+          return await this.diff(vault, args as HistoryDiffArgs);
+        case 'qa360.history.trend':
+          return await this.trend(vault, args as HistoryTrendArgs);
+        case 'qa360.history.export':
+          return await this.export(vault, args as HistoryExportArgs);
+        case 'qa360.history.gc':
+          return await this.gc(vault, args as HistoryGCArgs);
+        case 'qa360.history.pin':
+          return await this.pin(vault, args as HistoryPinArgs, true);
+        case 'qa360.history.unpin':
+          return await this.pin(vault, args as HistoryPinArgs, false);
+        default:
+          throw new Error(`Unknown history tool: ${toolName}`);
+      }
+    } finally {
+      await vault.close();
+    }
+  }
+
+  /**
+   * List runs with optional filters
+   */
+  private async list(vault: EvidenceVault, args: HistoryListArgs) {
+    const { limit = 20, status = 'any', gate, since } = args;
+
+    const filters: any = { limit };
+
+    if (status !== 'any') {
+      filters.status = [status];
+    }
+
+    if (since) {
+      filters.since = new Date(since);
+    }
+
+    const runs = await vault.listRuns(filters);
+
+    // If gate filter is specified, filter runs that have that gate
+    let filteredRuns = runs;
+    if (gate) {
+      filteredRuns = [];
+      for (const run of runs) {
+        const gates = await vault.getGates(run.id);
+        if (gates.some(g => g.name === gate)) {
+          filteredRuns.push(run);
+        }
+      }
+    }
+
+    // Build gates summary for each run
+    const runsWithSummary = await Promise.all(
+      filteredRuns.map(async (run) => {
+        const gates = await vault.getGates(run.id);
+        const gatesSummary: Record<string, string> = {};
+        gates.forEach(gate => {
+          gatesSummary[gate.name] = gate.status;
+        });
+
+        return {
+          id: run.id,
+          started_at: run.started_at,
+          status: run.status,
+          trust_score: run.trust_score,
+          gates_summary: gatesSummary
+        };
+      })
+    );
+
+    return { runs: runsWithSummary };
+  }
+
+  /**
+   * Get detailed run information
+   */
+  private async get(vault: EvidenceVault, args: HistoryGetArgs) {
+    const { runId } = args;
+
+    const run = await vault.getRun(runId);
+    if (!run) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+
+    // Get associated data
+    const [gates, findings, artifacts] = await Promise.all([
+      vault.getGates(runId),
+      vault.getFindings(runId),
+      vault.getRunArtifacts(runId)
+    ]);
+
+    return {
+      run: {
+        id: run.id,
+        started_at: run.started_at,
+        ended_at: run.ended_at,
+        status: run.status,
+        trust_score: run.trust_score,
+        pack_path: run.pack_path,
+        pack_hash: run.pack_hash,
+        run_key: run.run_key
+      },
+      gates: gates.map(gate => ({
+        name: gate.name,
+        status: gate.status,
+        duration_ms: gate.duration_ms || 0,
+        metrics: gate.metrics_json ? JSON.parse(gate.metrics_json) : {}
+      })),
+      findings: findings.map(finding => ({
+        gate: finding.gate,
+        severity: finding.severity,
+        rule: finding.rule,
+        location: finding.location,
+        message: finding.message
+      })),
+      artifacts: artifacts.map(artifact => ({
+        label: artifact.label,
+        sha256: artifact.sha256,
+        mime_type: artifact.mime_type,
+        size_bytes: artifact.size_bytes
+      }))
+    };
+  }
+
+  /**
+   * Compare two runs
+   */
+  private async diff(vault: EvidenceVault, args: HistoryDiffArgs) {
+    const { runA, runB } = args;
+
+    const [runAData, runBData] = await Promise.all([
+      this.get(vault, { runId: runA }),
+      this.get(vault, { runId: runB })
+    ]);
+
+    // Calculate trust score delta
+    const trustDelta = (runAData.run.trust_score || 0) - (runBData.run.trust_score || 0);
+
+    // Compare gates
+    const gateChanges: Record<string, any> = {};
+    const allGateNames = new Set([
+      ...runAData.gates.map(g => g.name),
+      ...runBData.gates.map(g => g.name)
+    ]);
+
+    for (const gateName of allGateNames) {
+      const gateA = runAData.gates.find(g => g.name === gateName);
+      const gateB = runBData.gates.find(g => g.name === gateName);
+
+      if (!gateA && gateB) {
+        gateChanges[gateName] = { status_change: `new → ${gateB.status}` };
+      } else if (gateA && !gateB) {
+        gateChanges[gateName] = { status_change: `${gateA.status} → removed` };
+      } else if (gateA && gateB) {
+        const changes: any = {};
+        if (gateA.status !== gateB.status) {
+          changes.status_change = `${gateA.status} → ${gateB.status}`;
+        }
+        if (gateA.duration_ms !== gateB.duration_ms) {
+          changes.duration_delta_ms = (gateB.duration_ms || 0) - (gateA.duration_ms || 0);
+        }
+        if (Object.keys(changes).length > 0) {
+          gateChanges[gateName] = changes;
+        }
+      }
+    }
+
+    // Compare findings (simplified)
+    const findingsA = new Set(runAData.findings.map(f => `${f.gate}:${f.rule}:${f.location}`));
+    const findingsB = new Set(runBData.findings.map(f => `${f.gate}:${f.rule}:${f.location}`));
+
+    const addedFindings = runBData.findings.filter(f => 
+      !findingsA.has(`${f.gate}:${f.rule}:${f.location}`)
+    );
+    const removedFindings = runAData.findings.filter(f => 
+      !findingsB.has(`${f.gate}:${f.rule}:${f.location}`)
+    );
+
+    return {
+      delta: {
+        trust: trustDelta,
+        gates: gateChanges,
+        findings: {
+          added: addedFindings,
+          removed: removedFindings,
+          regressed: [] // Could implement regression detection
+        }
+      }
+    };
+  }
+
+  /**
+   * Analyze trends over time
+   */
+  private async trend(vault: EvidenceVault, args: HistoryTrendArgs) {
+    const { gate, window = 20 } = args;
+
+    const runs = await vault.listRuns({ limit: window });
+
+    const series: Array<{ timestamp: number; value: number; metadata: { status: string; findings_count: number } }> = [];
+    let totalTrust = 0;
+    let totalFindings = 0;
+
+    for (const run of runs) {
+      let value = run.trust_score || 0;
+      
+      if (gate) {
+        // Focus on specific gate metrics
+        const gates = await vault.getGates(run.id);
+        const targetGate = gates.find(g => g.name === gate);
+        if (targetGate) {
+          // Use gate duration as the metric for trends
+          value = targetGate.duration_ms || 0;
+        }
+      }
+
+      const findings = await vault.getFindings(run.id);
+      
+      series.push({
+        timestamp: run.started_at,
+        value,
+        metadata: {
+          status: run.status,
+          findings_count: findings.length
+        }
+      });
+
+      totalTrust += run.trust_score || 0;
+      totalFindings += findings.length;
+    }
+
+    // Calculate trend direction
+    const recentValues = series.slice(0, Math.min(5, series.length)).map(s => s.value);
+    const olderValues = series.slice(-Math.min(5, series.length)).map(s => s.value);
+    
+    const recentAvg = recentValues.reduce((a, b) => a + b, 0) / recentValues.length;
+    const olderAvg = olderValues.reduce((a, b) => a + b, 0) / olderValues.length;
+    
+    let trend: 'up' | 'down' | 'stable' = 'stable';
+    if (recentAvg > olderAvg * 1.1) trend = 'up';
+    else if (recentAvg < olderAvg * 0.9) trend = 'down';
+
+    return {
+      series: series.reverse(), // Most recent first
+      summary: {
+        average: totalTrust / Math.max(runs.length, 1),
+        trend,
+        window_size: runs.length
+      }
+    };
+  }
+
+  /**
+   * Export run bundle
+   */
+  private async export(vault: EvidenceVault, args: HistoryExportArgs) {
+    const { runId, bundlePath } = args;
+
+    const run = await vault.getRun(runId);
+    if (!run) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+
+    // Get all run data
+    const [gates, findings, artifacts] = await Promise.all([
+      vault.getGates(runId),
+      vault.getFindings(runId),
+      vault.getRunArtifacts(runId)
+    ]);
+
+    // Create export data
+    const exportData = {
+      run,
+      gates,
+      findings,
+      artifacts: artifacts.map(a => ({
+        ...a,
+        // Note: In a real implementation, we'd include the actual file content
+        content_note: 'Artifact content available in CAS'
+      }))
+    };
+
+    // For now, simulate bundle creation
+    // In a real implementation, this would create a ZIP file with all artifacts
+    const bundleSize = JSON.stringify(exportData).length;
+
+    return {
+      bundlePath: resolve(bundlePath),
+      size_bytes: bundleSize,
+      contents: [
+        'run.json',
+        'gates.json', 
+        'findings.json',
+        'artifacts/',
+        'metadata.json'
+      ]
+    };
+  }
+
+  /**
+   * Garbage collection
+   */
+  private async gc(vault: EvidenceVault, args: HistoryGCArgs) {
+    const { keepLast = 50, maxBytes, dryRun = false } = args;
+
+    // Get vault statistics
+    const stats = await vault.getStats();
+    
+    // For now, simulate GC operation
+    // In a real implementation, this would:
+    // 1. Find runs older than keepLast
+    // 2. Check if they're pinned
+    // 3. Calculate space savings
+    // 4. Actually delete if not dryRun
+
+    const totalRuns = stats.totalRuns;
+    const runsToDelete = Math.max(0, totalRuns - keepLast);
+    const estimatedBytesFreed = runsToDelete * 1024 * 1024; // 1MB per run estimate
+
+    if (!dryRun && runsToDelete > 0) {
+      // In a real implementation, perform actual cleanup
+      console.log(`Would delete ${runsToDelete} runs`);
+    }
+
+    return {
+      removed: {
+        runs: dryRun ? 0 : runsToDelete,
+        artifacts: dryRun ? 0 : runsToDelete * 3, // Estimate
+        bytesFreed: dryRun ? 0 : estimatedBytesFreed
+      },
+      dryRun
+    };
+  }
+
+  /**
+   * Pin/unpin runs
+   */
+  private async pin(vault: EvidenceVault, args: HistoryPinArgs, pinned: boolean) {
+    const { runId } = args;
+
+    const run = await vault.getRun(runId);
+    if (!run) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+
+    await vault.pinRun(runId, pinned);
+
+    return {
+      success: true,
+      runId,
+      pinned,
+      message: `Run ${pinned ? 'pinned' : 'unpinned'} successfully`
+    };
+  }
+}