zephyr-enterprise-tools 1.3.0 → 1.3.1

package/README.md

@@ -11,6 +11,7 @@ Comprehensive tools for Zephyr Enterprise — Release Readiness, Project Health,
 | Tool | Description | Thresholds |
 |------|-------------|------------|
 | `release-readiness` | Run all 4 quality gates | Combined assessment |
+| `compare-releases` | Compare readiness across two releases | MCP/programmatic API |
 | `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 |
@@ -28,7 +29,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 |
 
 ---
 
@@ -66,6 +70,7 @@ 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 |
+| `compare_releases` | `projectId`, `releaseId1`, `releaseId2`, `query?` _(ZQL)_ | Compare readiness between two releases in the same project |
 | `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 |
@@ -77,13 +82,18 @@ 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_burndown` date range** — Use `startDate` and `endDate` (format: `YYYY-MM-DD`) to scope the burndown to a specific period within the release window.
+> **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 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.
 
 ---
 
@@ -179,6 +189,15 @@ 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
 
@@ -199,6 +218,7 @@ zephyr-enterprise-tools --help
 | `-q, --query <text>` | Keyword query (for `search-tests`) or ZQL expression (for `test-plan`) |
 | `-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` |
@@ -230,6 +250,9 @@ const tools = new ZephyrEnterpriseTools({
 const report = await tools.runAllGates(364, 4312);
 console.log(report.overallStatus); // "GO" | "CONDITIONAL GO" | "NO GO"
 
+const comparison = await tools.compareReleases(364, 4312, 4313, { query: 'priority = "P1"' });
+console.log(comparison.overallStatusChanged); // true when release readiness status changed
+
 // Individual gates
 const coverage  = await tools.requirementCoverageGate(364, 4312);
 const planning  = await tools.testPlanAnalysisGate(364, 4312);
@@ -247,6 +270,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({

package/cli.js

@@ -43,6 +43,8 @@ function parseArgs() {
     days: 30,
     limit: 50,
     cycleId: null,
+    startDate: null,
+    endDate: null,
   };
   
   for (let i = 0; i < args.length; i++) {
@@ -81,6 +83,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;
@@ -146,6 +154,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>)         │
   └─────────────────────────────────────────────────────────────────────────────┘
@@ -173,6 +183,9 @@ 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
 
@@ -427,6 +440,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}):`);
@@ -568,6 +592,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;

package/mcp-server.js

@@ -197,6 +197,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).',
@@ -374,6 +388,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,6 +1,6 @@
 {
   "name": "zephyr-enterprise-tools",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "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

@@ -221,6 +221,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;
@@ -323,6 +351,8 @@ 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>;

package/zephyr-enterprise-tools.js

@@ -1803,6 +1803,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 = {}) {