qa360 2.2.1 → 2.2.13

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

@@ -1,388 +0,0 @@
-/**
- * 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`
-    };
-  }
-}