zephyr-enterprise-tools 1.3.0 → 1.3.2

package/README.md

@@ -1,21 +1,11 @@
 # Zephyr Enterprise Tools
 
-Comprehensive tools for Zephyr Enterprise — Release Readiness, Project Health, Test Analytics & More.
+Comprehensive tools for Zephyr Enterprise — Project Health, Test Analytics & More.
 
 ---
 
 ## 🛠️ Available Tools
 
-### 🚦 Release Readiness (Quality Gates)
-
-| Tool | Description | Thresholds |
-|------|-------------|------------|
-| `release-readiness` | Run all 4 quality gates | Combined assessment |
-| `requirement-coverage` | Are requirements covered by tests? | ≥70% = GO |
-| `test-plan` | Are tests planned and assigned? | <80% = NO GO, 80–90% = CONDITIONAL, ≥90% = GO |
-| `test-execution` | Have tests been executed? | <90% = NO GO, 90–97% = CONDITIONAL, ≥97% = GO |
-| `defect-quality` | Are critical defects resolved? | Blocker > 0 = NO GO, High-risk > 10 = NO GO |
-
 ### 📊 Analytics & Insights
 
 | Tool | Description |
@@ -28,7 +18,10 @@ Comprehensive tools for Zephyr Enterprise — Release Readiness, Project Health,
 | `search-tests` | Search test cases by keyword query |
 | `user-activity` | User activity and productivity metrics |
 | `user-trend` | Full audit log history for a user — every action across the system, filterable by date range, entity type, and operation |
+| `execution-burnup` | Day-by-day execution burnup (cumulative executed vs ideal and total scope), supports optional date range filtering |
 | `execution-burndown` | Day-by-day execution burndown (remaining vs ideal), supports optional date range filtering |
+| `list-cycles` | List all test cycles for a release, including phases and execution status counts |
+| `get-cycle` | Get full details for a single test cycle |
 
 ---
 
@@ -65,11 +58,6 @@ Use `zephyr-enterprise-tools` as an MCP (Model Context Protocol) server with you
 |------|-----------|-------------|
 | `list_projects` | _(none)_ | List all Zephyr projects |
 | `list_releases` | `projectId` | List releases for a project |
-| `release_readiness` | `projectId`, `releaseId` | Run all 4 quality gates |
-| `requirement_coverage` | `projectId`, `releaseId` | Check requirement coverage |
-| `test_plan_analysis` | `projectId`, `releaseId`, `query?` _(ZQL)_ | Analyze test planning status — supports ZQL filter e.g. `priority = "P1"` |
-| `test_execution` | `projectId`, `releaseId` | Check test execution progress |
-| `defect_quality` | `projectId`, `releaseId` | Analyze defect status |
 | `project_health` | `projectId`, `releaseId` | Get project health score |
 | `test_coverage` | `projectId`, `releaseId` | Get test coverage details |
 | `failed_tests` | `projectId`, `releaseId`, `limit?` | List failed tests |
@@ -77,13 +65,16 @@ Use `zephyr-enterprise-tools` as an MCP (Model Context Protocol) server with you
 | `search_test_cases` | `projectId`, `releaseId`, `query?`, `limit?` | Search test cases by keyword |
 | `user_activity` | `projectId`, `releaseId`, `days?` | Get user activity metrics |
 | `user_trend` | `userName`*, `fromDate?`, `toDate?`, `entity?`, `operation?`, `pageSize?`, `offset?` | Full audit log history for a user |
+| `execution_burnup` | `projectId`, `releaseId`, `startDate?`, `endDate?` | Day-by-day burnup chart data with cumulative executed, ideal, and scope counts |
 | `execution_burndown` | `projectId`, `releaseId`, `startDate?`, `endDate?` | Day-by-day burndown chart data |
+| `list_cycles` | `releaseId` | List all test cycles for a release, including phases and execution status counts |
+| `get_cycle` | `cycleId` | Get full details for a single test cycle, including phases |
 
 > **\* `user_trend` — `userName` must be the user's full email address** (e.g. `jane.doe@yourcompany.com`). Short names or display names will return 0 results. `pageSize` supports up to 1000 records per request.
 
-> **`test_plan_analysis` ZQL filter** — Use the `query` parameter to scope results to a specific priority, e.g. `priority = "P1"`. This is the recommended way to filter test plan metrics by priority. Note: `search_test_cases` accepts keyword queries but does not support ZQL priority filtering.
+> **Execution chart date range** — Use `startDate` and `endDate` (format: `YYYY-MM-DD`) to scope `execution_burnup` and `execution_burndown` to a specific period within the release window.
 
-> **`execution_burndown` date range** — Use `startDate` and `endDate` (format: `YYYY-MM-DD`) to scope the burndown to a specific period within the release window.
+> **Execution status IDs** — Test execution, failed tests, trends, user activity, burnup, burndown, and cycle status counts resolve status IDs from Zephyr v4 system preferences using `testresult.testresultStatus.LOV` from `/admin/preference/all/system`. Built-in IDs are used only as a fallback when the preference cannot be loaded or parsed.
 
 ---
 
@@ -162,9 +153,6 @@ Add to your `mcp.json` configuration:
 The CLI binary is `zephyr-enterprise-tools`:
 
 ```bash
-# Run all quality gates (release readiness)
-zephyr-enterprise-tools -p <projectId> -r <releaseId>
-
 # Run a specific tool
 zephyr-enterprise-tools -p 364 -r 4312 -t project-health
 zephyr-enterprise-tools -p 364 -r 4312 -t failed-tests
@@ -173,12 +161,18 @@ zephyr-enterprise-tools -p 364 -r 4312 -t user-activity
 # Search test cases by keyword
 zephyr-enterprise-tools -p 364 -r 4312 -t search-tests -q "login"
 
-# Test plan analysis filtered to P1 priority (ZQL)
-zephyr-enterprise-tools -p 364 -r 4312 -t test-plan -q 'priority = "P1"'
-
 # Get trends for last 14 days
 zephyr-enterprise-tools -p 364 -r 4312 -t test-trends -d 14
 
+# Get execution burnup chart data
+zephyr-enterprise-tools -p 364 -r 4312 -t execution-burnup --start-date 2026-07-22 --end-date 2026-08-27
+
+# List all cycles and phase details for a release
+zephyr-enterprise-tools -p 364 -r 4312 -t list-cycles
+
+# Get one cycle by ID
+zephyr-enterprise-tools -p 364 -r 4312 -t get-cycle -c 98765
+
 # Get user audit log (full email required)
 zephyr-enterprise-tools -t user-trend --user jane.doe@yourcompany.com --page-size 1000
 
@@ -195,10 +189,11 @@ zephyr-enterprise-tools --help
 |--------|-------------|
 | `-p, --project <id>` | Project ID (required for most tools) |
 | `-r, --release <id>` | Release ID (required for most tools) |
-| `-t, --tool <name>` | Tool to run (default: `release-readiness`) |
-| `-q, --query <text>` | Keyword query (for `search-tests`) or ZQL expression (for `test-plan`) |
+| `-t, --tool <name>` | Tool to run (default: `project-health`) |
+| `-q, --query <text>` | Keyword query for `search-tests` |
 | `-d, --days <n>` | Days for trends/activity (default: 30) |
 | `-l, --limit <n>` | Max results (default: 50) |
+| `-c, --cycle <id>` | Cycle ID for `get-cycle` |
 | `--user <email>` | Full email address for `user-trend` |
 | `--page-size <n>` | Records per page for `user-trend` (max: 1000) |
 | `--start-date <YYYY-MM-DD>` | Start date for `execution-burndown` |
@@ -226,17 +221,6 @@ const tools = new ZephyrEnterpriseTools({
   token: 'your-api-token',
 });
 
-// ── Release Readiness ──────────────────────────────────────
-const report = await tools.runAllGates(364, 4312);
-console.log(report.overallStatus); // "GO" | "CONDITIONAL GO" | "NO GO"
-
-// Individual gates
-const coverage  = await tools.requirementCoverageGate(364, 4312);
-const planning  = await tools.testPlanAnalysisGate(364, 4312);
-const planningP1 = await tools.testPlanAnalysisGate(364, 4312, { query: 'priority = "P1"' });
-const execution = await tools.testExecutionGate(364, 4312);
-const defects   = await tools.defectQualityGate(364, 4312);
-
 // ── Analytics & Insights ───────────────────────────────────
 const health      = await tools.getProjectHealth(364, 4312);
 console.log(health.healthScore); // 0–100
@@ -247,6 +231,14 @@ const reqCoverage = await tools.getRequirementCoverage(364, 4312);
 const trends      = await tools.getTestCaseTrends(364, 4312, { days: 14 });
 const results     = await tools.searchTestCases(364, 4312, { query: 'login' });
 const activity    = await tools.getUserActivity(364, 4312, { days: 30 });
+const cycles      = await tools.listCycles(4312);
+const cycle       = await tools.getCycle(98765);
+
+// Burnup with optional date range
+const burnup      = await tools.getExecutionBurnup(364, 4312, {
+  startDate: '2026-07-22',
+  endDate:   '2026-08-27',
+});
 
 // User audit log — full email address required; pageSize up to 1000
 const auditLog    = await tools.getUserTrend({
@@ -267,27 +259,6 @@ const burndown    = await tools.getExecutionBurndown(364, 4312, {
 
 ## 📊 Sample Outputs
 
-### Release Readiness Report
-
-```
-════════════════════════════════════════════════════════════════════════════════
-                    RELEASE READINESS REPORT
-════════════════════════════════════════════════════════════════════════════════
-Project: 364  |  Release: 4312  |  2026-08-12T10:30:00.000Z
-────────────────────────────────────────────────────────────────────────────────
-
-┌─────────────────────────┬──────────┬──────────────────┬─────────────────────────┐
-│ Gate                    │ Score    │ Status           │ Threshold               │
-├─────────────────────────┼──────────┼──────────────────┼─────────────────────────┤
-│ Requirement Coverage    │ 37.04%   │ 🔴 NO GO         │ ≥70% coverage           │
-│ Test Plan Analysis      │ 19.53%   │ 🔴 NO GO         │ ≥90% planned & assigned │
-│ Test Execution          │ 80%      │ 🔴 NO GO         │ ≥97% executed           │
-│ Defect Quality          │ 0B / 0H  │ 🟢 GO            │ 0 blockers, ≤10 high    │
-└─────────────────────────┴──────────┴──────────────────┴─────────────────────────┘
-
-OVERALL: 🔴 NO GO  (1/4 passed, 3 failed, 0 conditional)
-```
-
 ### Project Health
 
 ```
@@ -331,60 +302,6 @@ Health Score: 🟡 65/100 (MODERATE)
 
 ## 🔧 CI/CD Integration
 
-### GitHub Actions
-
-```yaml
-- name: Check Release Readiness
-  env:
-    ZEPHYR_BASE_URL: ${{ secrets.ZEPHYR_BASE_URL }}
-    ZEPHYR_TOKEN: ${{ secrets.ZEPHYR_TOKEN }}
-  run: |
-    npx zephyr-enterprise-tools -p ${{ vars.PROJECT_ID }} -r ${{ vars.RELEASE_ID }} --json > report.json
-    cat report.json
-```
-
-### Jenkins
-
-```groovy
-stage('Quality Gates') {
-  environment {
-    ZEPHYR_BASE_URL = credentials('zephyr-base-url')
-    ZEPHYR_TOKEN    = credentials('zephyr-token')
-  }
-  steps {
-    sh 'npx zephyr-enterprise-tools -p ${PROJECT_ID} -r ${RELEASE_ID}'
-  }
-}
-```
-
----
-
-## 📝 Customizing Thresholds
-
-Edit `quality-gates.js`:
-
-```javascript
-export const THRESHOLDS = {
-  requirementCoverage: {
-    go: 70,           // Raise to 80 for stricter coverage requirements
-  },
-  testPlanAnalysis: {
-    noGo: 80,
-    conditionalGo: 90,
-  },
-  testExecution: {
-    noGo: 90,
-    conditionalGo: 97,
-  },
-  defectQuality: {
-    blockerLimit: 0,
-    highRiskLimit: 10, // Lower to 5 for a stricter defect policy
-  }
-};
-```
-
----
-
 ## 🐛 Common Issues
 
 | Problem | Cause | Fix |

package/cli.js

@@ -3,7 +3,7 @@
 /**
  * Zephyr Enterprise Tools CLI
  * 
- * Run release readiness checks and analytics from the command line.
+ * Run Zephyr analytics from the command line.
  * 
  * Usage:
  *   export ZEPHYR_BASE_URL="https://your-zephyr.com/flex/services/rest/latest"
@@ -35,14 +35,15 @@ function parseArgs() {
   const options = {
     projectId: null,
     releaseId: null,
-    tool: 'release-readiness',
-    gate: null, // Legacy support
+    tool: 'project-health',
     format: 'table',
     help: false,
     query: '',
     days: 30,
     limit: 50,
     cycleId: null,
+    startDate: null,
+    endDate: null,
   };
   
   for (let i = 0; i < args.length; i++) {
@@ -60,11 +61,6 @@ function parseArgs() {
       case '--tool':
         options.tool = args[++i];
         break;
-      case '-g':
-      case '--gate':
-        // Legacy support - map to tool
-        options.gate = args[++i];
-        break;
       case '-q':
       case '--query':
         options.query = args[++i] || '';
@@ -81,6 +77,12 @@ function parseArgs() {
       case '--cycle':
         options.cycleId = Number(args[++i]);
         break;
+      case '--start-date':
+        options.startDate = args[++i] || null;
+        break;
+      case '--end-date':
+        options.endDate = args[++i] || null;
+        break;
       case '--json':
         options.format = 'json';
         break;
@@ -94,11 +96,6 @@ function parseArgs() {
     }
   }
   
-  // Legacy gate support
-  if (options.gate) {
-    options.tool = options.gate === 'all' ? 'release-readiness' : options.gate;
-  }
-  
   return options;
 }
 
@@ -118,7 +115,7 @@ REQUIRED:
   -r, --release <id>    Release ID
 
 OPTIONS:
-  -t, --tool <name>     Tool to run (default: release-readiness)
+  -t, --tool <name>     Tool to run (default: project-health)
   -q, --query <text>    Search query (for search-tests)
   -d, --days <n>        Number of days for trends/activity (default: 30)
   -l, --limit <n>       Max results to return (default: 50)
@@ -129,15 +126,7 @@ OPTIONS:
 
 AVAILABLE TOOLS:
   ┌─────────────────────────────────────────────────────────────────────────────┐
-  │ RELEASE READINESS (Quality Gates)                                           │
-  ├─────────────────────────────────────────────────────────────────────────────┤
-  │  release-readiness     Run all 4 quality gates (default)                   │
-  │  requirement-coverage  Requirement coverage gate only                       │
-  │  test-plan             Test plan analysis gate only                         │
-  │  test-execution        Test execution gate only                             │
-  │  defect-quality        Defect quality gate only                             │
-  ├─────────────────────────────────────────────────────────────────────────────┤
-  │ ANALYTICS & INSIGHTS                                                        │
+  │ AVAILABLE ANALYTICS                                                         │
   ├─────────────────────────────────────────────────────────────────────────────┤
   │  project-health        Overall project health score and metrics             │
   │  test-coverage         Detailed test coverage analysis                      │
@@ -146,6 +135,8 @@ AVAILABLE TOOLS:
   │  test-trends           Test execution trends over time                      │
   │  search-tests          Search test cases by query                           │
   │  user-activity         User activity and productivity metrics               │
+  │  execution-burnup      Day-by-day execution burnup chart                    │
+  │  execution-burndown    Day-by-day execution burndown chart                  │
   │  list-cycles           List all cycles for a release with phase details      │
   │  get-cycle             Get full details for one cycle (-c <cycleId>)         │
   └─────────────────────────────────────────────────────────────────────────────┘
@@ -155,9 +146,6 @@ ENVIRONMENT VARIABLES:
   ZEPHYR_TOKEN          API token for authentication (required)
 
 EXAMPLES:
-  # Run all quality gates (release readiness)
-  zephyr-tools -p 364 -r 4312
-
   # Check project health
   zephyr-tools -p 364 -r 4312 -t project-health
 
@@ -173,89 +161,18 @@ EXAMPLES:
   # Get user activity report
   zephyr-tools -p 364 -r 4312 -t user-activity
 
+  # Get execution burnup chart data
+  zephyr-tools -p 364 -r 4312 -t execution-burnup --start-date 2026-07-22 --end-date 2026-08-27
+
   # List all cycles and phase details for a release
   zephyr-tools -p 364 -r 4312 -t list-cycles
 
   # Get a single cycle detail
   zephyr-tools -p 364 -r 4312 -t get-cycle -c 98765
 
-QUALITY GATE THRESHOLDS:
-  Requirement Coverage:  ≥70% = GO
-  Test Plan Analysis:    <80% = NO GO, 80-90% = CONDITIONAL, ≥90% = GO
-  Test Execution:        <90% = NO GO, 90-97% = CONDITIONAL, ≥97% = GO
-  Defect Quality:        Blocker >0 = NO GO, High-risk >10 = NO GO
 `);
 }
 
-// ─── Formatters ───────────────────────────────────────────────────────────────
-
-function formatTable(report) {
-  const { gates, overallStatus, summary, recommendation } = report;
-  
-  const statusIcon = (s) => s === 'GO' ? '🟢' : s === 'CONDITIONAL GO' ? '🟡' : s === 'NO GO' ? '🔴' : '⚪';
-  
-  console.log('\n' + '═'.repeat(80));
-  console.log('                    RELEASE READINESS REPORT');
-  console.log('═'.repeat(80));
-  console.log(`Project: ${report.projectId}  |  Release: ${report.releaseId}  |  ${report.timestamp}`);
-  console.log('─'.repeat(80));
-  
-  console.log('\n┌─────────────────────────┬──────────┬───────────┬─────────────────────────┐');
-  console.log('│ Gate                    │ Score    │ Status    │ Threshold               │');
-  console.log('├─────────────────────────┼──────────┼───────────┼─────────────────────────┤');
-  
-  // Gate 1
-  const g1 = gates.requirementCoverage;
-  console.log(`│ Requirement Coverage    │ ${String(g1.coveragePercentage + '%').padEnd(8)} │ ${statusIcon(g1.status)} ${g1.status.padEnd(7)} │ ≥70% coverage           │`);
-  
-  // Gate 2
-  const g2 = gates.testPlanAnalysis;
-  console.log(`│ Test Plan Analysis      │ ${String(g2.overallPlanningPercentage + '%').padEnd(8)} │ ${statusIcon(g2.status)} ${g2.status.padEnd(7)} │ ≥90% planned & assigned │`);
-  
-  // Gate 3
-  const g3 = gates.testExecution;
-  console.log(`│ Test Execution          │ ${String(g3.executionPercentage + '%').padEnd(8)} │ ${statusIcon(g3.status)} ${g3.status.padEnd(7)} │ ≥97% executed           │`);
-  
-  // Gate 4
-  const g4 = gates.defectQuality;
-  const defectScore = `${g4.breakdown?.blocker?.count || 0}B/${g4.breakdown?.highRisk?.count || 0}H`;
-  console.log(`│ Defect Quality          │ ${defectScore.padEnd(8)} │ ${statusIcon(g4.status)} ${g4.status.padEnd(7)} │ 0 blocker, ≤10 high     │`);
-  
-  console.log('└─────────────────────────┴──────────┴───────────┴─────────────────────────┘');
-  
-  console.log('\n' + '─'.repeat(80));
-  console.log(`OVERALL: ${statusIcon(overallStatus)} ${overallStatus}  (${summary.passed}/4 passed, ${summary.failed} failed, ${summary.conditional} conditional)`);
-  console.log('─'.repeat(80));
-  console.log('\n' + recommendation);
-  console.log('\n' + '═'.repeat(80) + '\n');
-}
-
-function formatSingleGate(result) {
-  const statusIcon = (s) => s === 'GO' ? '🟢' : s === 'CONDITIONAL GO' ? '🟡' : s === 'NO GO' ? '🔴' : '⚪';
-  
-  console.log('\n' + '─'.repeat(60));
-  console.log(`${result.gate.toUpperCase()} GATE`);
-  console.log('─'.repeat(60));
-  console.log(`Status: ${statusIcon(result.status)} ${result.status}`);
-  console.log(`Message: ${result.statusMessage}`);
-  
-  if (result.coveragePercentage !== undefined) {
-    console.log(`Coverage: ${result.coveragePercentage}% (${result.coveredRequirements}/${result.totalRequirements})`);
-  }
-  if (result.overallPlanningPercentage !== undefined) {
-    console.log(`Planning: ${result.overallPlanningPercentage}%`);
-  }
-  if (result.executionPercentage !== undefined) {
-    console.log(`Execution: ${result.executionPercentage}% (${result.completedTests}/${result.totalPlannedTests})`);
-    const b = result.breakdown;
-    console.log(`Breakdown: ✅${b.passed} ❌${b.failed} ⏸️${b.blocked} 🔄${b.wip} ⏳${b.notExecuted}`);
-  }
-  if (result.breakdown?.blocker !== undefined) {
-    console.log(`Defects: ${result.breakdown.blocker.count} blocker, ${result.breakdown.highRisk.count} high-risk, ${result.breakdown.lowRisk.count} low-risk`);
-  }
-  console.log('─'.repeat(60) + '\n');
-}
-
 // ─── Generic Result Formatter ─────────────────────────────────────────────────
 
 function formatGenericResult(result) {
@@ -427,6 +344,17 @@ function formatGenericResult(result) {
     console.log('   └────────────┴───────┴────────┴────────┴─────────┘');
   }
 
+  if (result.dailyBurnup && result.dailyBurnup.length > 0) {
+    console.log('\n📈 DAILY BURNUP (last 10 days):');
+    console.log('   ┌────────────┬────────┬────────────┬───────┬───────┐');
+    console.log('   │ Date       │ Today  │ Cumulative │ Ideal │ Scope │');
+    console.log('   ├────────────┼────────┼────────────┼───────┼───────┤');
+    for (const day of result.dailyBurnup.slice(-10)) {
+      console.log(`   │ ${day.date} │ ${String(day.executedToday).padEnd(6)} │ ${String(day.cumulativeExecuted).padEnd(10)} │ ${String(day.ideal).padEnd(5)} │ ${String(day.scope).padEnd(5)} │`);
+    }
+    console.log('   └────────────┴────────┴────────────┴───────┴───────┘');
+  }
+
   // Cycles list/detail
   if (result.cycles && result.cycles.length > 0) {
     console.log(`\n🔁 CYCLES (${result.total || result.cycles.length}):`);
@@ -528,25 +456,6 @@ async function main() {
     const { projectId, releaseId, tool, query, days, limit } = options;
     
     switch (tool) {
-      // Quality Gates (Release Readiness)
-      case 'release-readiness':
-      case 'all':
-        result = await tools.runAllGates(projectId, releaseId);
-        break;
-      case 'requirement-coverage':
-        result = await tools.requirementCoverageGate(projectId, releaseId);
-        break;
-      case 'test-plan':
-        result = await tools.testPlanAnalysisGate(projectId, releaseId);
-        break;
-      case 'test-execution':
-        result = await tools.testExecutionGate(projectId, releaseId);
-        break;
-      case 'defect-quality':
-        result = await tools.defectQualityGate(projectId, releaseId);
-        break;
-      
-      // Analytics & Insights
       case 'project-health':
         result = await tools.getProjectHealth(projectId, releaseId);
         break;
@@ -568,6 +477,18 @@ async function main() {
       case 'user-activity':
         result = await tools.getUserActivity(projectId, releaseId, { days });
         break;
+      case 'execution-burnup':
+        result = await tools.getExecutionBurnup(projectId, releaseId, {
+          startDate: options.startDate,
+          endDate: options.endDate,
+        });
+        break;
+      case 'execution-burndown':
+        result = await tools.getExecutionBurndown(projectId, releaseId, {
+          startDate: options.startDate,
+          endDate: options.endDate,
+        });
+        break;
       case 'list-cycles':
         result = await tools.listCycles(releaseId);
         break;
@@ -584,18 +505,10 @@ async function main() {
         console.error('Use --help to see available tools.');
         process.exit(1);
     }
-    
     if (options.format === 'json') {
       console.log(JSON.stringify(result, null, 2));
     } else {
-      // Use appropriate formatter
-      if (tool === 'release-readiness' || tool === 'all') {
-        formatTable(result);
-      } else if (['requirement-coverage', 'test-plan', 'test-execution', 'defect-quality'].includes(tool)) {
-        formatSingleGate(result);
-      } else {
-        formatGenericResult(result);
-      }
+      formatGenericResult(result);
     }
     
     // Exit code based on status

package/mcp-server.js

@@ -18,82 +18,6 @@ import QualityGates from './zephyr-enterprise-tools.js';
 // ─── Tool Definitions ─────────────────────────────────────────────────────────
 
 const TOOLS = [
-  {
-    name: 'release_readiness',
-    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'],
-    },
-  },
-  {
-    name: 'compare_releases',
-    description: 'Run release readiness for two releases in the same project and return a side-by-side diff across all 4 gates, including which gate statuses changed and their metric deltas.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectId: { type: 'number', description: 'Zephyr project ID' },
-        releaseId1: { type: 'number', description: 'First (baseline) Zephyr release ID' },
-        releaseId2: { type: 'number', description: 'Second (comparison) Zephyr release ID' },
-        query: { type: 'string', description: 'Optional Zephyr ZQL expression for Test Plan Analysis, e.g. priority = "P1"' },
-      },
-      required: ['projectId', 'releaseId1', 'releaseId2'],
-    },
-  },
-  {
-    name: 'requirement_coverage',
-    description: 'Check if requirements are covered by test cases. Threshold: ≥70% = GO.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectId: { type: 'number', description: 'Zephyr project ID' },
-        releaseId: { type: 'number', description: 'Zephyr release ID' },
-      },
-      required: ['projectId', 'releaseId'],
-    },
-  },
-  {
-    name: 'test_plan_analysis',
-    description: 'Analyze test planning status, optionally scoped to testcase IDs returned by a Zephyr ZQL expression. Threshold: <80% = NO GO, 80-90% = CONDITIONAL, ≥90% = GO.',
-    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, e.g. priority = "P1"' },
-      },
-      required: ['projectId', 'releaseId'],
-    },
-  },
-  {
-    name: 'test_execution',
-    description: 'Check test execution progress. Threshold: <90% = NO GO, 90-97% = CONDITIONAL, ≥97% = GO.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectId: { type: 'number', description: 'Zephyr project ID' },
-        releaseId: { type: 'number', description: 'Zephyr release ID' },
-      },
-      required: ['projectId', 'releaseId'],
-    },
-  },
-  {
-    name: 'defect_quality',
-    description: 'Analyze defect status. Threshold: Blocker >0 = NO GO, High-risk >10 = NO GO.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectId: { type: 'number', description: 'Zephyr project ID' },
-        releaseId: { type: 'number', description: 'Zephyr release ID' },
-      },
-      required: ['projectId', 'releaseId'],
-    },
-  },
   {
     name: 'project_health',
     description: 'Get overall project health score (0-100) with metrics, team info, releases, and recommendations.',
@@ -197,6 +121,20 @@ const TOOLS = [
       required: ['projectId', 'releaseId'],
     },
   },
+  {
+    name: 'execution_burnup',
+    description: 'Generate a day-by-day execution burnup chart for a release. Returns cumulative executed vs ideal and total scope counts for charting progress over time.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectId: { type: 'number', description: 'Zephyr project ID' },
+        releaseId: { type: 'number', description: 'Zephyr release ID' },
+        startDate: { type: 'string', description: 'Burnup start date YYYY-MM-DD (default: earliest execution date)' },
+        endDate:   { type: 'string', description: 'Burnup end date YYYY-MM-DD (default: today)' },
+      },
+      required: ['projectId', 'releaseId'],
+    },
+  },
   {
     name: 'user_trend',
     description: 'Get full audit log activity for a user — every action they performed across the system. Filter by date range and optionally by entity type (project or release).',
@@ -312,30 +250,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const releaseId = args.releaseId;
     
     switch (name) {
-      case 'release_readiness':
-        result = await tools.runAllGates(projectId, releaseId, { query: args.query });
-        break;
-        
-      case 'compare_releases':
-        result = await tools.compareReleases(projectId, args.releaseId1, args.releaseId2, { query: args.query });
-        break;
-        
-      case 'requirement_coverage':
-        result = await tools.requirementCoverageGate(projectId, releaseId);
-        break;
-        
-      case 'test_plan_analysis':
-        result = await tools.testPlanAnalysisGate(projectId, releaseId, { query: args.query });
-        break;
-        
-      case 'test_execution':
-        result = await tools.testExecutionGate(projectId, releaseId);
-        break;
-        
-      case 'defect_quality':
-        result = await tools.defectQualityGate(projectId, releaseId);
-        break;
-        
       case 'project_health':
         result = await tools.getProjectHealth(projectId, releaseId);
         break;
@@ -374,6 +288,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         });
         break;
 
+      case 'execution_burnup':
+        result = await tools.getExecutionBurnup(projectId, releaseId, {
+          startDate: args.startDate || null,
+          endDate:   args.endDate   || null,
+        });
+        break;
+
       case 'user_trend':
         result = await tools.getUserTrend({
           userName:  args.userName,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zephyr-enterprise-tools",
-  "version": "1.3.0",
-  "description": "Comprehensive Zephyr Enterprise Tools - Release Readiness, Project Health, Test Analytics & More",
+  "version": "1.3.2",
+  "description": "Comprehensive Zephyr Enterprise Tools - Project Health, Test Analytics & More",
   "main": "zephyr-enterprise-tools.js",
   "types": "zephyr-enterprise-tools.d.ts",
   "exports": {
@@ -29,8 +29,6 @@
   "keywords": [
     "zephyr",
     "zephyr-enterprise",
-    "quality-gates",
-    "release-readiness",
     "testing",
     "qa",
     "test-management",

package/zephyr-enterprise-tools.d.ts

@@ -7,111 +7,8 @@ export interface ZephyrConfig {
   token?: string;
 }
 
-export interface ThresholdConfig {
-  requirementCoverage: { go: number; description: string };
-  testPlanAnalysis: { noGo: number; conditionalGo: number; description: string };
-  testExecution: { noGo: number; conditionalGo: number; description: string };
-  defectQuality: { blockerLimit: number; highRiskLimit: number; description: string };
-}
-
-export type GateStatus = "GO" | "CONDITIONAL GO" | "NO GO";
 export type HealthStatus = "HEALTHY" | "MODERATE" | "AT RISK" | "CRITICAL";
 
-export interface GateResult {
-  gate: string;
-  status: GateStatus;
-  statusMessage: string;
-  [key: string]: unknown;
-}
-
-export interface RequirementCoverageResult extends GateResult {
-  coveragePercentage: number;
-  coveredRequirements: number;
-  notCoveredRequirements: number;
-  totalRequirements: number;
-}
-
-export interface TestPlanResult extends GateResult {
-  overallPlanningPercentage: number;
-  totalTests: number;
-  plannedTests: number;
-  assignedTests: number;
-}
-
-export interface TestPlanOptions {
-  /** Optional Zephyr ZQL expression, e.g. `priority = "P1"`. */
-  query?: string;
-}
-
-export interface TestExecutionResult extends GateResult {
-  executionPercentage: number;
-  completedTests: number;
-  totalPlannedTests: number;
-  breakdown: {
-    passed: number;
-    failed: number;
-    blocked: number;
-    wip: number;
-    notExecuted: number;
-  };
-}
-
-export interface DefectQualityResult extends GateResult {
-  totalDefects: number;
-  breakdown: {
-    blocker: { count: number; defects: unknown[] };
-    highRisk: { count: number; defects: unknown[] };
-    lowRisk: { count: number; defects: unknown[] };
-    resolved: { count: number };
-  };
-}
-
-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;
-    testPlanAnalysis: TestPlanResult;
-    testExecution: TestExecutionResult;
-    defectQuality: DefectQualityResult;
-  };
-}
-
-export interface GateComparison {
-  metric: string;
-  releaseA: { status: GateStatus; value: number };
-  releaseB: { status: GateStatus; value: number };
-  delta: number;
-  statusChanged: boolean;
-  trend: 'improved' | 'regressed' | 'unchanged';
-}
-
-export interface CompareReleasesResult {
-  projectId: number;
-  timestamp: string;
-  query?: string;
-  releaseA: { releaseId: number; projectName: string; releaseName: string; generatedAt: string; fileName: string; overallStatus: GateStatus };
-  releaseB: { releaseId: number; projectName: string; releaseName: string; generatedAt: string; fileName: string; overallStatus: GateStatus };
-  overallStatusChanged: boolean;
-  gates: {
-    requirementCoverage: GateComparison;
-    testPlanAnalysis: GateComparison;
-    testExecution: GateComparison;
-    defectQuality: GateComparison;
-  };
-}
-
 export interface ProjectHealthResult {
   tool: string;
   projectId: number;
@@ -221,6 +118,34 @@ export interface ListUsersOptions {
   pageSize?: number;
 }
 
+export interface ExecutionChartOptions {
+  startDate?: string | null;
+  endDate?: string | null;
+}
+
+export interface ExecutionBurnupDay {
+  date: string;
+  executedToday: number;
+  cumulativeExecuted: number;
+  remaining: number;
+  completionPct: number;
+  ideal: number;
+  scope: number;
+}
+
+export interface ExecutionBurnupResult {
+  tool: string;
+  projectId: number;
+  releaseId: number;
+  timestamp: string;
+  dateRange?: { from: string; to: string };
+  total: number;
+  totalPlanned: number;
+  summary?: Record<string, unknown>;
+  message?: string;
+  dailyBurnup: ExecutionBurnupDay[];
+}
+
 export interface ZephyrUser {
   id: number;
   fullName: string;
@@ -307,14 +232,6 @@ export interface GetCycleResult {
 export declare class QualityGates {
   constructor(config: ZephyrConfig);
 
-  // Quality Gates (Release Readiness)
-  requirementCoverageGate(projectId: number, releaseId: number): Promise<RequirementCoverageResult>;
-  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, options?: TestPlanOptions): Promise<ReleaseReadinessResult>;
-  compareReleases(projectId: number, releaseId1: number, releaseId2: number, options?: TestPlanOptions): Promise<CompareReleasesResult>;
-
   // Analytics & Insights
   getProjectHealth(projectId: number, releaseId: number): Promise<ProjectHealthResult>;
   getTestCoverage(projectId: number, releaseId: number): Promise<TestCoverageResult>;
@@ -323,17 +240,13 @@ export declare class QualityGates {
   getTestCaseTrends(projectId: number, releaseId: number, options?: TrendsOptions): Promise<TestTrendsResult>;
   searchTestCases(projectId: number, releaseId: number, options?: SearchTestCasesOptions): Promise<SearchTestCasesResult>;
   getUserActivity(projectId: number, releaseId: number, options?: UserActivityOptions): Promise<UserActivityResult>;
+  getExecutionBurndown(projectId: number, releaseId: number, options?: ExecutionChartOptions): Promise<Record<string, unknown>>;
+  getExecutionBurnup(projectId: number, releaseId: number, options?: ExecutionChartOptions): Promise<ExecutionBurnupResult>;
   listUsers(projectId: number, options?: ListUsersOptions): Promise<ListUsersResult>;
   listCycles(releaseId: number): Promise<ListCyclesResult>;
   getCycle(cycleId: number): Promise<GetCycleResult>;
 }
 
-export declare const THRESHOLDS: ThresholdConfig;
-export declare const RESOLVED_STATUSES: string[];
-export declare const BLOCKER_PRIORITIES: string[];
-export declare const HIGH_RISK_PRIORITIES: string[];
-export declare const LOW_RISK_PRIORITIES: string[];
-
 /** Alias for QualityGates — kept for backward compatibility */
 export { QualityGates as ZephyrTools };
 export default QualityGates;

package/zephyr-enterprise-tools.js

@@ -3,12 +3,6 @@
  * 
  * Provides comprehensive tools for Zephyr Enterprise:
  * 
- * RELEASE READINESS (Quality Gates):
- *   1. Requirement Coverage Gate - Are requirements covered by tests?
- *   2. Test Plan Analysis Gate - Are tests planned and assigned?
- *   3. Test Execution Gate - Have tests been executed?
- *   4. Defect Quality Gate - Are critical defects resolved?
- * 
  * ANALYTICS & INSIGHTS:
  *   5. Project Health - Overall project health metrics
  *   6. Test Coverage - Detailed test coverage analysis
@@ -21,13 +15,12 @@
  * Usage:
  *   import { ZephyrTools } from './quality-gates.js';
  *   const tools = new ZephyrTools({ baseUrl, username, password });
- *   const report = await tools.runAllGates(projectId, releaseId);
  *   const health = await tools.getProjectHealth(projectId, releaseId);
  */
 
-// ─── Configuration & Thresholds ───────────────────────────────────────────────
+// ─── Configuration ────────────────────────────────────────────────────────────
 
-export const THRESHOLDS = {
+const THRESHOLDS = {
   requirementCoverage: {
     go: 70,
     description: "≥70% coverage = GO, <70% = NO GO"
@@ -1803,6 +1796,123 @@ export class QualityGates {
     };
   }
 
+  async getExecutionBurnup(projectId, releaseId, options = {}) {
+    const { startDate = null, endDate = null } = options;
+    const statusMap = await this.getTestResultStatusMap();
+
+    const executionsById = new Map();
+    let currentOffset = 0;
+    const pageSize = 10000;
+
+    while (true) {
+      const executionData = await this.GET('/execution', {
+        releaseid: releaseId,
+        offset: currentOffset,
+        pagesize: pageSize,
+        includeanyoneuser: true,
+      });
+      const page = executionData.results || executionData || [];
+
+      if (!Array.isArray(page) || page.length === 0) break;
+
+      const sizeBefore = executionsById.size;
+      for (const exec of page) executionsById.set(exec.id, exec);
+      currentOffset += page.length;
+
+      if (executionsById.size === sizeBefore) break;
+    }
+
+    const executions = [...executionsById.values()];
+    const total = executions.length;
+    const totalPlanned = total;
+
+    if (total === 0) {
+      return {
+        tool: 'Execution Burnup',
+        projectId,
+        releaseId,
+        timestamp: new Date().toISOString(),
+        total: 0,
+        totalPlanned: 0,
+        message: 'No executions found for this release.',
+        dailyBurnup: [],
+      };
+    }
+
+    const allDates = executions
+      .map(e => e.lastModifiedOn || e.createDatetime)
+      .filter(Boolean)
+      .map(d => new Date(d).toISOString().split('T')[0]);
+
+    const rangeStart = startDate || allDates.reduce((a, b) => (a < b ? a : b));
+    const rangeEnd = endDate || new Date().toISOString().split('T')[0];
+
+    const executedByDate = {};
+    for (const exec of executions) {
+      const rawDate = exec.lastModifiedOn || exec.createDatetime;
+      if (!rawDate) continue;
+      const dateKey = new Date(rawDate).toISOString().split('T')[0];
+      if (dateKey < rangeStart || dateKey > rangeEnd) continue;
+      if (!this.isExecutionStatus(exec, statusMap, "unexecuted")) {
+        executedByDate[dateKey] = (executedByDate[dateKey] || 0) + 1;
+      }
+    }
+
+    const days = [];
+    let current = new Date(rangeStart);
+    const end = new Date(rangeEnd);
+    let cumulativeExecuted = 0;
+
+    while (current <= end) {
+      const dateKey = current.toISOString().split('T')[0];
+      const executedToday = executedByDate[dateKey] || 0;
+      cumulativeExecuted += executedToday;
+
+      days.push({
+        date: dateKey,
+        executedToday,
+        cumulativeExecuted,
+        remaining: Math.max(0, total - cumulativeExecuted),
+        completionPct: Math.round((cumulativeExecuted / total) * 100),
+      });
+
+      current.setDate(current.getDate() + 1);
+    }
+
+    const totalDays = days.length;
+    const idealDailyBurnup = totalDays > 1 ? total / (totalDays - 1) : total;
+    const dailyBurnup = days.map((day, i) => ({
+      ...day,
+      ideal: Math.min(total, Math.round(idealDailyBurnup * i)),
+      scope: total,
+    }));
+
+    const lastDay = dailyBurnup[dailyBurnup.length - 1];
+    const behindBy = lastDay.ideal - lastDay.cumulativeExecuted;
+
+    return {
+      tool: 'Execution Burnup',
+      projectId,
+      releaseId,
+      timestamp: new Date().toISOString(),
+      dateRange: { from: rangeStart, to: rangeEnd },
+      total,
+      totalPlanned,
+      summary: {
+        totalExecutions: total,
+        executed: lastDay.cumulativeExecuted,
+        remaining: lastDay.remaining,
+        completionPct: lastDay.completionPct,
+        status: behindBy > 0
+          ? `⚠️ Behind ideal by ${behindBy} tests`
+          : behindBy < 0
+            ? `✅ Ahead of schedule by ${Math.abs(behindBy)} tests`
+            : '✅ On track',
+      },
+      dailyBurnup,
+    };
+  }
+
   // ─── User Trend (Audit Logs) ─────────────────────────────────────────────────
 
   async getUserTrend(options = {}) {