zephyr-enterprise-tools 1.2.6 → 1.2.7

package/mcp-server.js

@@ -20,12 +20,13 @@ import QualityGates from './zephyr-enterprise-tools.js';
 const TOOLS = [
   {
     name: 'release_readiness',
-    description: 'Run all 4 quality gates to assess release readiness. Returns GO, CONDITIONAL GO, or NO GO status.',
+    description: 'Run all 4 quality gates with calculation details and action items. Optionally scope Test Plan Analysis to a Zephyr ZQL expression. Returns GO, CONDITIONAL GO, or NO GO status.',
     inputSchema: {
       type: 'object',
       properties: {
         projectId: { type: 'number', description: 'Zephyr project ID' },
         releaseId: { type: 'number', description: 'Zephyr release ID' },
+        query: { type: 'string', description: 'Optional Zephyr ZQL expression for Test Plan Analysis, e.g. priority = "P1"' },
       },
       required: ['projectId', 'releaseId'],
     },
@@ -265,7 +266,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     
     switch (name) {
       case 'release_readiness':
-        result = await tools.runAllGates(projectId, releaseId);
+        result = await tools.runAllGates(projectId, releaseId, { query: args.query });
         break;
         
       case 'requirement_coverage':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zephyr-enterprise-tools",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "description": "Comprehensive Zephyr Enterprise Tools - Release Readiness, Project Health, Test Analytics & More",
   "main": "zephyr-enterprise-tools.js",
   "types": "zephyr-enterprise-tools.d.ts",

package/zephyr-enterprise-tools.d.ts

@@ -70,8 +70,15 @@ export interface ReleaseReadinessResult {
   projectId: number;
   releaseId: number;
   timestamp: string;
+  report: {
+    projectName: string;
+    releaseName: string;
+    generatedAt: string;
+    fileName: string;
+  };
   overallStatus: GateStatus;
   summary: { passed: number; failed: number; conditional: number };
+  details: Record<string, unknown>;
   recommendation: string;
   gates: {
     requirementCoverage: RequirementCoverageResult;
@@ -185,7 +192,7 @@ export declare class QualityGates {
   testPlanAnalysisGate(projectId: number, releaseId: number, options?: TestPlanOptions): Promise<TestPlanResult>;
   testExecutionGate(projectId: number, releaseId: number): Promise<TestExecutionResult>;
   defectQualityGate(projectId: number, releaseId: number): Promise<DefectQualityResult>;
-  runAllGates(projectId: number, releaseId: number): Promise<ReleaseReadinessResult>;
+  runAllGates(projectId: number, releaseId: number, options?: TestPlanOptions): Promise<ReleaseReadinessResult>;
 
   // Analytics & Insights
   getProjectHealth(projectId: number, releaseId: number): Promise<ProjectHealthResult>;

package/zephyr-enterprise-tools.js

@@ -540,13 +540,20 @@ export class QualityGates {
 
   // ─── Run All Gates ──────────────────────────────────────────────────────────
 
-  async runAllGates(projectId, releaseId) {
-    const results = await Promise.all([
-      this.requirementCoverageGate(projectId, releaseId),
-      this.testPlanAnalysisGate(projectId, releaseId),
-      this.testExecutionGate(projectId, releaseId),
-      this.defectQualityGate(projectId, releaseId),
+  async runAllGates(projectId, releaseId, options = {}) {
+    const { query } = options;
+    const [results, project, releases] = await Promise.all([
+      Promise.all([
+        this.requirementCoverageGate(projectId, releaseId),
+        this.testPlanAnalysisGate(projectId, releaseId, { query }),
+        this.testExecutionGate(projectId, releaseId),
+        this.defectQualityGate(projectId, releaseId),
+      ]),
+      this.GET(`/project/${projectId}`).catch(() => ({})),
+      this.GET('/release', { projectid: projectId, isaliasallowed: false }).catch(() => []),
     ]);
+    const release = Array.isArray(releases) ? releases.find(item => Number(item.id) === Number(releaseId)) : undefined;
+    const generatedAt = new Date().toISOString();
     
     const gates = {
       requirementCoverage: results[0],
@@ -576,7 +583,13 @@ export class QualityGates {
     return {
       projectId,
       releaseId,
-      timestamp: new Date().toISOString(),
+      timestamp: generatedAt,
+      report: {
+        projectName: project.name || `Project ${projectId}`,
+        releaseName: release?.name || `Release ${releaseId}`,
+        generatedAt,
+        fileName: this.getReportFileName(project.name || `Project ${projectId}`, release?.name || `Release ${releaseId}`, generatedAt),
+      },
       overallStatus,
       summary: {
         passed: passedGates,
@@ -585,10 +598,72 @@ export class QualityGates {
         total: 4,
       },
       gates,
+      details: this.getReadinessDetails(gates, query),
       recommendation: this.getRecommendation(overallStatus, gates),
     };
   }
 
+  getReportFileName(projectName, releaseName, generatedAt) {
+    const safeSegment = value => String(value)
+      .trim()
+      .replace(/[^a-zA-Z0-9]+/g, '_')
+      .replace(/^_+|_+$/g, '');
+    const timestamp = new Date(generatedAt).toISOString();
+    const date = timestamp.slice(0, 10);
+    const time = timestamp.slice(11, 19).replace(/:/g, '-');
+
+    return `Release_Rediness_${safeSegment(projectName)}_${safeSegment(releaseName)}_${date}_${time}_UTC.pdf`;
+  }
+
+  getReadinessDetails(gates, query) {
+    const plan = gates.testPlanAnalysis;
+    const coverage = gates.requirementCoverage;
+    const execution = gates.testExecution;
+    const defects = gates.defectQuality;
+    const planAnalysis = plan.analysis;
+    const remainingToPlan = Math.max(0, planAnalysis.testcasePlanning.totalTestcases - planAnalysis.testcasePlanning.plannedTestcases);
+    const remainingToExecute = execution.incompleteTests;
+    const additionalTestsForGo = Math.max(0, Math.ceil((0.97 * execution.totalPlannedTests) - execution.completedTests));
+
+    return {
+      testPlanAnalysis: {
+        scope: query ? "ZQL-filtered test cases" : "Release-wide",
+        query: query || undefined,
+        calculation: {
+          testcasePlanning: `${planAnalysis.testcasePlanning.plannedTestcases} / ${planAnalysis.testcasePlanning.totalTestcases} = ${planAnalysis.testcasePlanning.percentage}%`,
+          executionAssignment: `${planAnalysis.executionAssignment.assignedExecutions} / ${planAnalysis.executionAssignment.totalExecutions} = ${planAnalysis.executionAssignment.percentage}%`,
+          overallPlanning: `(${planAnalysis.testcasePlanning.percentage}% + ${planAnalysis.executionAssignment.percentage}%) / 2 = ${plan.overallPlanningPercentage}%`,
+        },
+        actionItems: remainingToPlan > 0
+          ? [`Plan the remaining ${remainingToPlan} test cases.`, "Maintain execution assignment as tests are planned."]
+          : ["Maintain complete test planning and execution assignment."],
+      },
+      requirementCoverage: {
+        scope: "Release-wide",
+        calculation: `${coverage.coveredRequirements} / ${coverage.totalRequirements} = ${coverage.coveragePercentage}%`,
+        uncoveredRequirementIds: [],
+        detailAvailability: "Zephyr release summaries provide the uncovered count but not requirement IDs.",
+        actionItems: coverage.notCoveredRequirements > 0
+          ? [`Create and map tests for ${coverage.notCoveredRequirements} uncovered requirements.`, "Confirm requirement mappings before release sign-off."]
+          : ["Maintain requirement-to-test traceability through release sign-off."],
+      },
+      testExecution: {
+        scope: "Release-wide",
+        calculation: `${execution.completedTests} / ${execution.totalPlannedTests} = ${execution.executionPercentage}%`,
+        actionItems: remainingToExecute > 0
+          ? [`Execute or resolve ${remainingToExecute} incomplete tests.`, `Complete at least ${additionalTestsForGo} additional tests to reach the 97% GO threshold.`, ...(execution.breakdown.failed > 0 ? [`Investigate and rerun ${execution.breakdown.failed} failed test(s).`] : [])]
+          : ["Maintain execution completion through release sign-off."],
+      },
+      defectQuality: {
+        scope: "Release-wide",
+        defects: defects.breakdown,
+        actionItems: defects.unresolvedDefects > 0
+          ? ["Resolve all blocker defects.", "Reduce unresolved high-risk defects to 10 or fewer before approval."]
+          : ["Verify resolved defect fixes with targeted regression coverage.", "Confirm product-owner approval for any Won't Fix resolutions."],
+      },
+    };
+  }
+
   getRecommendation(status, gates) {
     const issues = [];