@gaffer-sh/mcp 0.4.1 → 0.5.0

package/dist/index.js

@@ -1,518 +1,519 @@
 #!/usr/bin/env node
-
-// src/index.ts
+import { createRequire } from "node:module";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
 
-// src/api-client.ts
-var REQUEST_TIMEOUT_MS = 3e4;
-var MAX_RETRIES = 3;
-var INITIAL_RETRY_DELAY_MS = 1e3;
-var RETRYABLE_STATUS_CODES = [401, 429, 500, 502, 503, 504];
+//#region src/api-client.ts
+const pkg = createRequire(import.meta.url)("../package.json");
+const REQUEST_TIMEOUT_MS = 3e4;
+const MAX_RETRIES = 3;
+const INITIAL_RETRY_DELAY_MS = 1e3;
+const RETRYABLE_STATUS_CODES = [
+	401,
+	429,
+	500,
+	502,
+	503,
+	504
+];
+/**
+* Sleep for a given number of milliseconds
+*/
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/**
+* Detect token type from prefix
+* - gaf_ = user API Key (read-only, cross-project)
+* - gfr_ = Project Upload Token (legacy, single project)
+*/
 function detectTokenType(token) {
-  if (token.startsWith("gaf_")) {
-    return "user";
-  }
-  return "project";
+	if (token.startsWith("gaf_")) return "user";
+	return "project";
 }
-var GafferApiClient = class _GafferApiClient {
-  apiKey;
-  baseUrl;
-  tokenType;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.tokenType = detectTokenType(config.apiKey);
-  }
-  /**
-   * Create client from environment variables
-   *
-   * Supports:
-   * - GAFFER_API_KEY (for user API Keys gaf_)
-   */
-  static fromEnv() {
-    const apiKey = process.env.GAFFER_API_KEY;
-    if (!apiKey) {
-      throw new Error("GAFFER_API_KEY environment variable is required");
-    }
-    const baseUrl = process.env.GAFFER_API_URL || "https://app.gaffer.sh";
-    return new _GafferApiClient({ apiKey, baseUrl });
-  }
-  /**
-   * Check if using a user API Key (enables cross-project features)
-   */
-  isUserToken() {
-    return this.tokenType === "user";
-  }
-  /**
-   * Make authenticated request to Gaffer API with retry logic
-   */
-  async request(endpoint, params) {
-    const url = new URL(`/api/v1${endpoint}`, this.baseUrl);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== void 0 && value !== null) {
-          url.searchParams.set(key, String(value));
-        }
-      }
-    }
-    let lastError = null;
-    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-      try {
-        const response = await fetch(url.toString(), {
-          method: "GET",
-          headers: {
-            "X-API-Key": this.apiKey,
-            "Accept": "application/json",
-            "User-Agent": "gaffer-mcp/0.2.1"
-          },
-          signal: controller.signal
-        });
-        if (!response.ok) {
-          const errorData = await response.json().catch(() => ({}));
-          if (RETRYABLE_STATUS_CODES.includes(response.status) && attempt < MAX_RETRIES) {
-            let delayMs = INITIAL_RETRY_DELAY_MS * 2 ** attempt;
-            if (response.status === 429) {
-              const retryAfter = response.headers.get("Retry-After");
-              if (retryAfter) {
-                delayMs = Math.max(delayMs, Number.parseInt(retryAfter, 10) * 1e3);
-              }
-            }
-            lastError = new Error(errorData.error?.message || `API request failed: ${response.status}`);
-            await sleep(delayMs);
-            continue;
-          }
-          const errorMessage = errorData.error?.message || `API request failed: ${response.status}`;
-          throw new Error(errorMessage);
-        }
-        return response.json();
-      } catch (error) {
-        clearTimeout(timeoutId);
-        if (error instanceof Error && error.name === "AbortError") {
-          lastError = new Error(`Request timed out after ${REQUEST_TIMEOUT_MS}ms`);
-          if (attempt < MAX_RETRIES) {
-            await sleep(INITIAL_RETRY_DELAY_MS * 2 ** attempt);
-            continue;
-          }
-          throw lastError;
-        }
-        if (error instanceof TypeError && attempt < MAX_RETRIES) {
-          lastError = error;
-          await sleep(INITIAL_RETRY_DELAY_MS * 2 ** attempt);
-          continue;
-        }
-        throw error;
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    }
-    throw lastError || new Error("Request failed after retries");
-  }
-  /**
-   * List all projects the user has access to
-   * Requires user API Key (gaf_)
-   *
-   * @param options - Query options
-   * @param options.organizationId - Filter by organization ID
-   * @param options.limit - Maximum number of results
-   * @param options.offset - Offset for pagination
-   */
-  async listProjects(options = {}) {
-    if (!this.isUserToken()) {
-      throw new Error("listProjects requires a user API Key (gaf_). Upload Tokens (gfr_) can only access a single project.");
-    }
-    return this.request("/user/projects", {
-      ...options.organizationId && { organizationId: options.organizationId },
-      ...options.limit && { limit: options.limit },
-      ...options.offset && { offset: options.offset }
-    });
-  }
-  /**
-   * Get project health analytics
-   *
-   * @param options - Query options
-   * @param options.projectId - Required for user tokens, ignored for project tokens
-   * @param options.days - Analysis period in days (default: 30)
-   */
-  async getProjectHealth(options = {}) {
-    if (this.isUserToken()) {
-      if (!options.projectId) {
-        throw new Error("projectId is required when using a user API Key");
-      }
-      return this.request(`/user/projects/${options.projectId}/health`, {
-        days: options.days || 30
-      });
-    }
-    return this.request("/project/analytics", {
-      days: options.days || 30
-    });
-  }
-  /**
-   * Get test history for a specific test
-   *
-   * @param options - Query options
-   * @param options.projectId - Required for user tokens, ignored for project tokens
-   * @param options.testName - Test name to search for
-   * @param options.filePath - File path to search for
-   * @param options.limit - Maximum number of results
-   */
-  async getTestHistory(options) {
-    const testName = options.testName?.trim();
-    const filePath = options.filePath?.trim();
-    if (!testName && !filePath) {
-      throw new Error("Either testName or filePath is required (and must not be empty)");
-    }
-    if (this.isUserToken()) {
-      if (!options.projectId) {
-        throw new Error("projectId is required when using a user API Key");
-      }
-      return this.request(`/user/projects/${options.projectId}/test-history`, {
-        ...testName && { testName },
-        ...filePath && { filePath },
-        ...options.limit && { limit: options.limit }
-      });
-    }
-    return this.request("/project/test-history", {
-      ...testName && { testName },
-      ...filePath && { filePath },
-      ...options.limit && { limit: options.limit }
-    });
-  }
-  /**
-   * Get flaky tests for the project
-   *
-   * @param options - Query options
-   * @param options.projectId - Required for user tokens, ignored for project tokens
-   * @param options.threshold - Minimum flip rate to be considered flaky (0-1)
-   * @param options.limit - Maximum number of results
-   * @param options.days - Analysis period in days
-   */
-  async getFlakyTests(options = {}) {
-    if (this.isUserToken()) {
-      if (!options.projectId) {
-        throw new Error("projectId is required when using a user API Key");
-      }
-      return this.request(`/user/projects/${options.projectId}/flaky-tests`, {
-        ...options.threshold && { threshold: options.threshold },
-        ...options.limit && { limit: options.limit },
-        ...options.days && { days: options.days }
-      });
-    }
-    return this.request("/project/flaky-tests", {
-      ...options.threshold && { threshold: options.threshold },
-      ...options.limit && { limit: options.limit },
-      ...options.days && { days: options.days }
-    });
-  }
-  /**
-   * List test runs for the project
-   *
-   * @param options - Query options
-   * @param options.projectId - Required for user tokens, ignored for project tokens
-   * @param options.commitSha - Filter by commit SHA
-   * @param options.branch - Filter by branch name
-   * @param options.status - Filter by status ('passed' or 'failed')
-   * @param options.limit - Maximum number of results
-   */
-  async getTestRuns(options = {}) {
-    if (this.isUserToken()) {
-      if (!options.projectId) {
-        throw new Error("projectId is required when using a user API Key");
-      }
-      return this.request(`/user/projects/${options.projectId}/test-runs`, {
-        ...options.commitSha && { commitSha: options.commitSha },
-        ...options.branch && { branch: options.branch },
-        ...options.status && { status: options.status },
-        ...options.limit && { limit: options.limit }
-      });
-    }
-    return this.request("/project/test-runs", {
-      ...options.commitSha && { commitSha: options.commitSha },
-      ...options.branch && { branch: options.branch },
-      ...options.status && { status: options.status },
-      ...options.limit && { limit: options.limit }
-    });
-  }
-  /**
-   * Get report files for a test run
-   *
-   * @param testRunId - The test run ID
-   * @returns Report metadata with download URLs for each file
-   */
-  async getReport(testRunId) {
-    if (!this.isUserToken()) {
-      throw new Error("getReport requires a user API Key (gaf_). Upload Tokens (gfr_) cannot access reports via API.");
-    }
-    if (!testRunId) {
-      throw new Error("testRunId is required");
-    }
-    return this.request(`/user/test-runs/${testRunId}/report`);
-  }
-  /**
-   * Get slowest tests for a project
-   *
-   * @param options - Query options
-   * @param options.projectId - The project ID (required)
-   * @param options.days - Analysis period in days (default: 30)
-   * @param options.limit - Maximum number of results (default: 20)
-   * @param options.framework - Filter by test framework
-   * @param options.branch - Filter by git branch name
-   * @returns Slowest tests sorted by P95 duration
-   */
-  async getSlowestTests(options) {
-    if (!this.isUserToken()) {
-      throw new Error("getSlowestTests requires a user API Key (gaf_).");
-    }
-    if (!options.projectId) {
-      throw new Error("projectId is required");
-    }
-    return this.request(`/user/projects/${options.projectId}/slowest-tests`, {
-      ...options.days && { days: options.days },
-      ...options.limit && { limit: options.limit },
-      ...options.framework && { framework: options.framework },
-      ...options.branch && { branch: options.branch }
-    });
-  }
-  /**
-   * Get parsed test results for a specific test run
-   *
-   * @param options - Query options
-   * @param options.projectId - The project ID (required)
-   * @param options.testRunId - The test run ID (required)
-   * @param options.status - Filter by test status ('passed', 'failed', 'skipped')
-   * @param options.limit - Maximum number of results (default: 100)
-   * @param options.offset - Pagination offset (default: 0)
-   * @returns Parsed test cases with pagination
-   */
-  async getTestRunDetails(options) {
-    if (!this.isUserToken()) {
-      throw new Error("getTestRunDetails requires a user API Key (gaf_).");
-    }
-    if (!options.projectId) {
-      throw new Error("projectId is required");
-    }
-    if (!options.testRunId) {
-      throw new Error("testRunId is required");
-    }
-    return this.request(
-      `/user/projects/${options.projectId}/test-runs/${options.testRunId}/details`,
-      {
-        ...options.status && { status: options.status },
-        ...options.limit && { limit: options.limit },
-        ...options.offset && { offset: options.offset }
-      }
-    );
-  }
-  /**
-   * Compare test metrics between two commits or test runs
-   *
-   * @param options - Query options
-   * @param options.projectId - The project ID (required)
-   * @param options.testName - The test name to compare (required)
-   * @param options.beforeCommit - Commit SHA for before (use with afterCommit)
-   * @param options.afterCommit - Commit SHA for after (use with beforeCommit)
-   * @param options.beforeRunId - Test run ID for before (use with afterRunId)
-   * @param options.afterRunId - Test run ID for after (use with beforeRunId)
-   * @returns Comparison of test metrics
-   */
-  async compareTestMetrics(options) {
-    if (!this.isUserToken()) {
-      throw new Error("compareTestMetrics requires a user API Key (gaf_).");
-    }
-    if (!options.projectId) {
-      throw new Error("projectId is required");
-    }
-    if (!options.testName) {
-      throw new Error("testName is required");
-    }
-    return this.request(
-      `/user/projects/${options.projectId}/compare-test`,
-      {
-        testName: options.testName,
-        ...options.beforeCommit && { beforeCommit: options.beforeCommit },
-        ...options.afterCommit && { afterCommit: options.afterCommit },
-        ...options.beforeRunId && { beforeRunId: options.beforeRunId },
-        ...options.afterRunId && { afterRunId: options.afterRunId }
-      }
-    );
-  }
-  /**
-   * Get coverage summary for a project
-   *
-   * @param options - Query options
-   * @param options.projectId - The project ID (required)
-   * @param options.days - Analysis period in days (default: 30)
-   * @returns Coverage summary with trends and lowest coverage files
-   */
-  async getCoverageSummary(options) {
-    if (!this.isUserToken()) {
-      throw new Error("getCoverageSummary requires a user API Key (gaf_).");
-    }
-    if (!options.projectId) {
-      throw new Error("projectId is required");
-    }
-    return this.request(
-      `/user/projects/${options.projectId}/coverage-summary`,
-      {
-        ...options.days && { days: options.days }
-      }
-    );
-  }
-  /**
-   * Get coverage files for a project with filtering
-   *
-   * @param options - Query options
-   * @param options.projectId - The project ID (required)
-   * @param options.filePath - Filter to specific file path
-   * @param options.minCoverage - Minimum coverage percentage
-   * @param options.maxCoverage - Maximum coverage percentage
-   * @param options.limit - Maximum number of results
-   * @param options.offset - Pagination offset
-   * @param options.sortBy - Sort by 'path' or 'coverage'
-   * @param options.sortOrder - Sort order 'asc' or 'desc'
-   * @returns List of files with coverage data
-   */
-  async getCoverageFiles(options) {
-    if (!this.isUserToken()) {
-      throw new Error("getCoverageFiles requires a user API Key (gaf_).");
-    }
-    if (!options.projectId) {
-      throw new Error("projectId is required");
-    }
-    return this.request(
-      `/user/projects/${options.projectId}/coverage/files`,
-      {
-        ...options.filePath && { filePath: options.filePath },
-        ...options.minCoverage !== void 0 && { minCoverage: options.minCoverage },
-        ...options.maxCoverage !== void 0 && { maxCoverage: options.maxCoverage },
-        ...options.limit && { limit: options.limit },
-        ...options.offset && { offset: options.offset },
-        ...options.sortBy && { sortBy: options.sortBy },
-        ...options.sortOrder && { sortOrder: options.sortOrder }
-      }
-    );
-  }
-  /**
-   * Get risk areas (files with low coverage AND test failures)
-   *
-   * @param options - Query options
-   * @param options.projectId - The project ID (required)
-   * @param options.days - Analysis period in days (default: 30)
-   * @param options.coverageThreshold - Include files below this coverage (default: 80)
-   * @returns List of risk areas sorted by risk score
-   */
-  async getCoverageRiskAreas(options) {
-    if (!this.isUserToken()) {
-      throw new Error("getCoverageRiskAreas requires a user API Key (gaf_).");
-    }
-    if (!options.projectId) {
-      throw new Error("projectId is required");
-    }
-    return this.request(
-      `/user/projects/${options.projectId}/coverage/risk-areas`,
-      {
-        ...options.days && { days: options.days },
-        ...options.coverageThreshold !== void 0 && { coverageThreshold: options.coverageThreshold }
-      }
-    );
-  }
-  /**
-   * Get a browser-navigable URL for viewing a test report
-   *
-   * @param options - Query options
-   * @param options.projectId - The project ID (required)
-   * @param options.testRunId - The test run ID (required)
-   * @param options.filename - Specific file to open (default: index.html)
-   * @returns URL with signed token for browser access
-   */
-  async getReportBrowserUrl(options) {
-    if (!this.isUserToken()) {
-      throw new Error("getReportBrowserUrl requires a user API Key (gaf_).");
-    }
-    if (!options.projectId) {
-      throw new Error("projectId is required");
-    }
-    if (!options.testRunId) {
-      throw new Error("testRunId is required");
-    }
-    return this.request(
-      `/user/projects/${options.projectId}/reports/${options.testRunId}/browser-url`,
-      {
-        ...options.filename && { filename: options.filename }
-      }
-    );
-  }
+/**
+* Gaffer API v1 client for MCP server
+*
+* Supports two authentication modes:
+* 1. User API Keys (gaf_) - Read-only access to all user's projects
+* 2. Project Upload Tokens (gfr_) - Legacy, single project access
+*/
+var GafferApiClient = class GafferApiClient {
+	apiKey;
+	baseUrl;
+	tokenType;
+	constructor(config) {
+		this.apiKey = config.apiKey;
+		this.baseUrl = config.baseUrl.replace(/\/$/, "");
+		this.tokenType = detectTokenType(config.apiKey);
+	}
+	/**
+	* Create client from environment variables
+	*
+	* Supports:
+	* - GAFFER_API_KEY (for user API Keys gaf_)
+	*/
+	static fromEnv() {
+		const apiKey = process.env.GAFFER_API_KEY;
+		if (!apiKey) throw new Error("GAFFER_API_KEY environment variable is required");
+		return new GafferApiClient({
+			apiKey,
+			baseUrl: process.env.GAFFER_API_URL || "https://app.gaffer.sh"
+		});
+	}
+	/**
+	* Check if using a user API Key (enables cross-project features)
+	*/
+	isUserToken() {
+		return this.tokenType === "user";
+	}
+	/**
+	* Make authenticated request to Gaffer API with retry logic
+	*/
+	async request(endpoint, params) {
+		const url = new URL(`/api/v1${endpoint}`, this.baseUrl);
+		if (params) {
+			for (const [key, value] of Object.entries(params)) if (value !== void 0 && value !== null) url.searchParams.set(key, String(value));
+		}
+		let lastError = null;
+		for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+			try {
+				const response = await fetch(url.toString(), {
+					method: "GET",
+					headers: {
+						"X-API-Key": this.apiKey,
+						"Accept": "application/json",
+						"User-Agent": `gaffer-mcp/${pkg.version}`
+					},
+					signal: controller.signal
+				});
+				if (!response.ok) {
+					const errorData = await response.json().catch(() => ({}));
+					if (RETRYABLE_STATUS_CODES.includes(response.status) && attempt < MAX_RETRIES) {
+						let delayMs = INITIAL_RETRY_DELAY_MS * 2 ** attempt;
+						if (response.status === 429) {
+							const retryAfter = response.headers.get("Retry-After");
+							if (retryAfter) delayMs = Math.max(delayMs, Number.parseInt(retryAfter, 10) * 1e3);
+						}
+						lastError = new Error(errorData.error?.message || `API request failed: ${response.status}`);
+						await sleep(delayMs);
+						continue;
+					}
+					const errorMessage = errorData.error?.message || `API request failed: ${response.status}`;
+					throw new Error(errorMessage);
+				}
+				return response.json();
+			} catch (error) {
+				clearTimeout(timeoutId);
+				if (error instanceof Error && error.name === "AbortError") {
+					lastError = /* @__PURE__ */ new Error(`Request timed out after ${REQUEST_TIMEOUT_MS}ms`);
+					if (attempt < MAX_RETRIES) {
+						await sleep(INITIAL_RETRY_DELAY_MS * 2 ** attempt);
+						continue;
+					}
+					throw lastError;
+				}
+				if (error instanceof TypeError && attempt < MAX_RETRIES) {
+					lastError = error;
+					await sleep(INITIAL_RETRY_DELAY_MS * 2 ** attempt);
+					continue;
+				}
+				throw error;
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		}
+		throw lastError || /* @__PURE__ */ new Error("Request failed after retries");
+	}
+	/**
+	* List all projects the user has access to
+	* Requires user API Key (gaf_)
+	*
+	* @param options - Query options
+	* @param options.organizationId - Filter by organization ID
+	* @param options.limit - Maximum number of results
+	* @param options.offset - Offset for pagination
+	*/
+	async listProjects(options = {}) {
+		if (!this.isUserToken()) throw new Error("listProjects requires a user API Key (gaf_). Upload Tokens (gfr_) can only access a single project.");
+		return this.request("/user/projects", {
+			...options.organizationId && { organizationId: options.organizationId },
+			...options.limit && { limit: options.limit },
+			...options.offset && { offset: options.offset }
+		});
+	}
+	/**
+	* Get project health analytics
+	*
+	* @param options - Query options
+	* @param options.projectId - Required for user tokens, ignored for project tokens
+	* @param options.days - Analysis period in days (default: 30)
+	*/
+	async getProjectHealth(options = {}) {
+		if (this.isUserToken()) {
+			if (!options.projectId) throw new Error("projectId is required when using a user API Key");
+			return this.request(`/user/projects/${options.projectId}/health`, { days: options.days || 30 });
+		}
+		return this.request("/project/analytics", { days: options.days || 30 });
+	}
+	/**
+	* Get test history for a specific test
+	*
+	* @param options - Query options
+	* @param options.projectId - Required for user tokens, ignored for project tokens
+	* @param options.testName - Test name to search for
+	* @param options.filePath - File path to search for
+	* @param options.limit - Maximum number of results
+	*/
+	async getTestHistory(options) {
+		const testName = options.testName?.trim();
+		const filePath = options.filePath?.trim();
+		if (!testName && !filePath) throw new Error("Either testName or filePath is required (and must not be empty)");
+		if (this.isUserToken()) {
+			if (!options.projectId) throw new Error("projectId is required when using a user API Key");
+			return this.request(`/user/projects/${options.projectId}/test-history`, {
+				...testName && { testName },
+				...filePath && { filePath },
+				...options.limit && { limit: options.limit }
+			});
+		}
+		return this.request("/project/test-history", {
+			...testName && { testName },
+			...filePath && { filePath },
+			...options.limit && { limit: options.limit }
+		});
+	}
+	/**
+	* Get flaky tests for the project
+	*
+	* @param options - Query options
+	* @param options.projectId - Required for user tokens, ignored for project tokens
+	* @param options.threshold - Minimum flip rate to be considered flaky (0-1)
+	* @param options.limit - Maximum number of results
+	* @param options.days - Analysis period in days
+	*/
+	async getFlakyTests(options = {}) {
+		if (this.isUserToken()) {
+			if (!options.projectId) throw new Error("projectId is required when using a user API Key");
+			return this.request(`/user/projects/${options.projectId}/flaky-tests`, {
+				...options.threshold && { threshold: options.threshold },
+				...options.limit && { limit: options.limit },
+				...options.days && { days: options.days }
+			});
+		}
+		return this.request("/project/flaky-tests", {
+			...options.threshold && { threshold: options.threshold },
+			...options.limit && { limit: options.limit },
+			...options.days && { days: options.days }
+		});
+	}
+	/**
+	* List test runs for the project
+	*
+	* @param options - Query options
+	* @param options.projectId - Required for user tokens, ignored for project tokens
+	* @param options.commitSha - Filter by commit SHA
+	* @param options.branch - Filter by branch name
+	* @param options.status - Filter by status ('passed' or 'failed')
+	* @param options.limit - Maximum number of results
+	*/
+	async getTestRuns(options = {}) {
+		if (this.isUserToken()) {
+			if (!options.projectId) throw new Error("projectId is required when using a user API Key");
+			return this.request(`/user/projects/${options.projectId}/test-runs`, {
+				...options.commitSha && { commitSha: options.commitSha },
+				...options.branch && { branch: options.branch },
+				...options.status && { status: options.status },
+				...options.limit && { limit: options.limit }
+			});
+		}
+		return this.request("/project/test-runs", {
+			...options.commitSha && { commitSha: options.commitSha },
+			...options.branch && { branch: options.branch },
+			...options.status && { status: options.status },
+			...options.limit && { limit: options.limit }
+		});
+	}
+	/**
+	* Get report files for a test run
+	*
+	* @param testRunId - The test run ID
+	* @returns Report metadata with download URLs for each file
+	*/
+	async getReport(testRunId) {
+		if (!this.isUserToken()) throw new Error("getReport requires a user API Key (gaf_). Upload Tokens (gfr_) cannot access reports via API.");
+		if (!testRunId) throw new Error("testRunId is required");
+		return this.request(`/user/test-runs/${testRunId}/report`);
+	}
+	/**
+	* Get slowest tests for a project
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.days - Analysis period in days (default: 30)
+	* @param options.limit - Maximum number of results (default: 20)
+	* @param options.framework - Filter by test framework
+	* @param options.branch - Filter by git branch name
+	* @returns Slowest tests sorted by P95 duration
+	*/
+	async getSlowestTests(options) {
+		if (!this.isUserToken()) throw new Error("getSlowestTests requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		return this.request(`/user/projects/${options.projectId}/slowest-tests`, {
+			...options.days && { days: options.days },
+			...options.limit && { limit: options.limit },
+			...options.framework && { framework: options.framework },
+			...options.branch && { branch: options.branch }
+		});
+	}
+	/**
+	* Get parsed test results for a specific test run
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.testRunId - The test run ID (required)
+	* @param options.status - Filter by test status ('passed', 'failed', 'skipped')
+	* @param options.limit - Maximum number of results (default: 100)
+	* @param options.offset - Pagination offset (default: 0)
+	* @returns Parsed test cases with pagination
+	*/
+	async getTestRunDetails(options) {
+		if (!this.isUserToken()) throw new Error("getTestRunDetails requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		if (!options.testRunId) throw new Error("testRunId is required");
+		return this.request(`/user/projects/${options.projectId}/test-runs/${options.testRunId}/details`, {
+			...options.status && { status: options.status },
+			...options.limit && { limit: options.limit },
+			...options.offset && { offset: options.offset }
+		});
+	}
+	/**
+	* Compare test metrics between two commits or test runs
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.testName - The test name to compare (required)
+	* @param options.beforeCommit - Commit SHA for before (use with afterCommit)
+	* @param options.afterCommit - Commit SHA for after (use with beforeCommit)
+	* @param options.beforeRunId - Test run ID for before (use with afterRunId)
+	* @param options.afterRunId - Test run ID for after (use with beforeRunId)
+	* @returns Comparison of test metrics
+	*/
+	async compareTestMetrics(options) {
+		if (!this.isUserToken()) throw new Error("compareTestMetrics requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		if (!options.testName) throw new Error("testName is required");
+		return this.request(`/user/projects/${options.projectId}/compare-test`, {
+			testName: options.testName,
+			...options.beforeCommit && { beforeCommit: options.beforeCommit },
+			...options.afterCommit && { afterCommit: options.afterCommit },
+			...options.beforeRunId && { beforeRunId: options.beforeRunId },
+			...options.afterRunId && { afterRunId: options.afterRunId }
+		});
+	}
+	/**
+	* Get coverage summary for a project
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.days - Analysis period in days (default: 30)
+	* @returns Coverage summary with trends and lowest coverage files
+	*/
+	async getCoverageSummary(options) {
+		if (!this.isUserToken()) throw new Error("getCoverageSummary requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		return this.request(`/user/projects/${options.projectId}/coverage-summary`, { ...options.days && { days: options.days } });
+	}
+	/**
+	* Get coverage files for a project with filtering
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.filePath - Filter to specific file path
+	* @param options.minCoverage - Minimum coverage percentage
+	* @param options.maxCoverage - Maximum coverage percentage
+	* @param options.limit - Maximum number of results
+	* @param options.offset - Pagination offset
+	* @param options.sortBy - Sort by 'path' or 'coverage'
+	* @param options.sortOrder - Sort order 'asc' or 'desc'
+	* @returns List of files with coverage data
+	*/
+	async getCoverageFiles(options) {
+		if (!this.isUserToken()) throw new Error("getCoverageFiles requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		return this.request(`/user/projects/${options.projectId}/coverage/files`, {
+			...options.filePath && { filePath: options.filePath },
+			...options.minCoverage !== void 0 && { minCoverage: options.minCoverage },
+			...options.maxCoverage !== void 0 && { maxCoverage: options.maxCoverage },
+			...options.limit && { limit: options.limit },
+			...options.offset && { offset: options.offset },
+			...options.sortBy && { sortBy: options.sortBy },
+			...options.sortOrder && { sortOrder: options.sortOrder }
+		});
+	}
+	/**
+	* Get risk areas (files with low coverage AND test failures)
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.days - Analysis period in days (default: 30)
+	* @param options.coverageThreshold - Include files below this coverage (default: 80)
+	* @returns List of risk areas sorted by risk score
+	*/
+	async getCoverageRiskAreas(options) {
+		if (!this.isUserToken()) throw new Error("getCoverageRiskAreas requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		return this.request(`/user/projects/${options.projectId}/coverage/risk-areas`, {
+			...options.days && { days: options.days },
+			...options.coverageThreshold !== void 0 && { coverageThreshold: options.coverageThreshold }
+		});
+	}
+	/**
+	* Get a browser-navigable URL for viewing a test report
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.testRunId - The test run ID (required)
+	* @param options.filename - Specific file to open (default: index.html)
+	* @returns URL with signed token for browser access
+	*/
+	async getReportBrowserUrl(options) {
+		if (!this.isUserToken()) throw new Error("getReportBrowserUrl requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		if (!options.testRunId) throw new Error("testRunId is required");
+		return this.request(`/user/projects/${options.projectId}/reports/${options.testRunId}/browser-url`, { ...options.filename && { filename: options.filename } });
+	}
+	/**
+	* Get failure clusters for a test run
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.testRunId - The test run ID (required)
+	* @returns Failure clusters grouped by error similarity
+	*/
+	async getFailureClusters(options) {
+		if (!this.isUserToken()) throw new Error("getFailureClusters requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		if (!options.testRunId) throw new Error("testRunId is required");
+		return this.request(`/user/projects/${options.projectId}/test-runs/${options.testRunId}/failure-clusters`);
+	}
+	/**
+	* List upload sessions for a project
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.commitSha - Filter by commit SHA
+	* @param options.branch - Filter by branch name
+	* @param options.limit - Maximum number of results (default: 10)
+	* @param options.offset - Pagination offset (default: 0)
+	* @returns Paginated list of upload sessions
+	*/
+	async listUploadSessions(options) {
+		if (!this.isUserToken()) throw new Error("listUploadSessions requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		return this.request(`/user/projects/${options.projectId}/upload-sessions`, {
+			...options.commitSha && { commitSha: options.commitSha },
+			...options.branch && { branch: options.branch },
+			...options.limit && { limit: options.limit },
+			...options.offset && { offset: options.offset }
+		});
+	}
+	/**
+	* Get upload session detail with linked results
+	*
+	* @param options - Query options
+	* @param options.projectId - The project ID (required)
+	* @param options.sessionId - The upload session ID (required)
+	* @returns Upload session details with linked test runs and coverage reports
+	*/
+	async getUploadSessionDetail(options) {
+		if (!this.isUserToken()) throw new Error("getUploadSessionDetail requires a user API Key (gaf_).");
+		if (!options.projectId) throw new Error("projectId is required");
+		if (!options.sessionId) throw new Error("sessionId is required");
+		return this.request(`/user/projects/${options.projectId}/upload-sessions/${options.sessionId}`);
+	}
 };
 
-// src/tools/compare-test-metrics.ts
-import { z } from "zod";
-var compareTestMetricsInputSchema = {
-  projectId: z.string().describe("Project ID. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
-  testName: z.string().describe("The test name to compare. Can be the short name or full name including describe blocks."),
-  beforeCommit: z.string().optional().describe('Commit SHA for the "before" measurement. Use with afterCommit.'),
-  afterCommit: z.string().optional().describe('Commit SHA for the "after" measurement. Use with beforeCommit.'),
-  beforeRunId: z.string().optional().describe('Test run ID for the "before" measurement. Use with afterRunId.'),
-  afterRunId: z.string().optional().describe('Test run ID for the "after" measurement. Use with beforeRunId.')
+//#endregion
+//#region src/tools/compare-test-metrics.ts
+/**
+* Input schema for compare_test_metrics tool
+*/
+const compareTestMetricsInputSchema = {
+	projectId: z.string().describe("Project ID. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
+	testName: z.string().describe("The test name to compare. Can be the short name or full name including describe blocks."),
+	beforeCommit: z.string().optional().describe("Commit SHA for the \"before\" measurement. Use with afterCommit."),
+	afterCommit: z.string().optional().describe("Commit SHA for the \"after\" measurement. Use with beforeCommit."),
+	beforeRunId: z.string().optional().describe("Test run ID for the \"before\" measurement. Use with afterRunId."),
+	afterRunId: z.string().optional().describe("Test run ID for the \"after\" measurement. Use with beforeRunId.")
 };
-var compareTestMetricsOutputSchema = {
-  testName: z.string(),
-  before: z.object({
-    testRunId: z.string(),
-    commit: z.string().nullable(),
-    branch: z.string().nullable(),
-    status: z.enum(["passed", "failed", "skipped"]),
-    durationMs: z.number().nullable(),
-    createdAt: z.string()
-  }),
-  after: z.object({
-    testRunId: z.string(),
-    commit: z.string().nullable(),
-    branch: z.string().nullable(),
-    status: z.enum(["passed", "failed", "skipped"]),
-    durationMs: z.number().nullable(),
-    createdAt: z.string()
-  }),
-  change: z.object({
-    durationMs: z.number().nullable(),
-    percentChange: z.number().nullable(),
-    statusChanged: z.boolean()
-  })
+/**
+* Output schema for compare_test_metrics tool
+*/
+const compareTestMetricsOutputSchema = {
+	testName: z.string(),
+	before: z.object({
+		testRunId: z.string(),
+		commit: z.string().nullable(),
+		branch: z.string().nullable(),
+		status: z.enum([
+			"passed",
+			"failed",
+			"skipped"
+		]),
+		durationMs: z.number().nullable(),
+		createdAt: z.string()
+	}),
+	after: z.object({
+		testRunId: z.string(),
+		commit: z.string().nullable(),
+		branch: z.string().nullable(),
+		status: z.enum([
+			"passed",
+			"failed",
+			"skipped"
+		]),
+		durationMs: z.number().nullable(),
+		createdAt: z.string()
+	}),
+	change: z.object({
+		durationMs: z.number().nullable(),
+		percentChange: z.number().nullable(),
+		statusChanged: z.boolean()
+	})
 };
+/**
+* Execute compare_test_metrics tool
+*/
 async function executeCompareTestMetrics(client, input) {
-  const hasCommits = input.beforeCommit && input.afterCommit;
-  const hasRunIds = input.beforeRunId && input.afterRunId;
-  if (!hasCommits && !hasRunIds) {
-    throw new Error("Must provide either (beforeCommit + afterCommit) or (beforeRunId + afterRunId)");
-  }
-  if (hasCommits) {
-    if (input.beforeCommit.trim().length === 0 || input.afterCommit.trim().length === 0) {
-      throw new Error("beforeCommit and afterCommit must not be empty strings");
-    }
-  }
-  if (hasRunIds) {
-    if (input.beforeRunId.trim().length === 0 || input.afterRunId.trim().length === 0) {
-      throw new Error("beforeRunId and afterRunId must not be empty strings");
-    }
-  }
-  const response = await client.compareTestMetrics({
-    projectId: input.projectId,
-    testName: input.testName,
-    beforeCommit: input.beforeCommit,
-    afterCommit: input.afterCommit,
-    beforeRunId: input.beforeRunId,
-    afterRunId: input.afterRunId
-  });
-  return response;
+	const hasCommits = input.beforeCommit && input.afterCommit;
+	const hasRunIds = input.beforeRunId && input.afterRunId;
+	if (!hasCommits && !hasRunIds) throw new Error("Must provide either (beforeCommit + afterCommit) or (beforeRunId + afterRunId)");
+	if (hasCommits) {
+		if (input.beforeCommit.trim().length === 0 || input.afterCommit.trim().length === 0) throw new Error("beforeCommit and afterCommit must not be empty strings");
+	}
+	if (hasRunIds) {
+		if (input.beforeRunId.trim().length === 0 || input.afterRunId.trim().length === 0) throw new Error("beforeRunId and afterRunId must not be empty strings");
+	}
+	return await client.compareTestMetrics({
+		projectId: input.projectId,
+		testName: input.testName,
+		beforeCommit: input.beforeCommit,
+		afterCommit: input.afterCommit,
+		beforeRunId: input.beforeRunId,
+		afterRunId: input.afterRunId
+	});
 }
-var compareTestMetricsMetadata = {
-  name: "compare_test_metrics",
-  title: "Compare Test Metrics",
-  description: `Compare test metrics between two commits or test runs.
+/**
+* Tool metadata
+*/
+const compareTestMetricsMetadata = {
+	name: "compare_test_metrics",
+	title: "Compare Test Metrics",
+	description: `Compare test metrics between two commits or test runs.
 
 Useful for measuring the impact of code changes on test performance or reliability.
 
@@ -549,46 +550,58 @@ Use cases:
 Tip: Use get_test_history first to find the commit SHAs or test run IDs you want to compare.`
 };
 
-// src/tools/find-uncovered-failure-areas.ts
-import { z as z2 } from "zod";
-var findUncoveredFailureAreasInputSchema = {
-  projectId: z2.string().describe("Project ID to analyze. Required. Use list_projects to find project IDs."),
-  days: z2.number().int().min(1).max(365).optional().describe("Number of days to analyze for test failures (default: 30)"),
-  coverageThreshold: z2.number().min(0).max(100).optional().describe("Include files with coverage below this percentage (default: 80)")
+//#endregion
+//#region src/tools/find-uncovered-failure-areas.ts
+/**
+* Input schema for find_uncovered_failure_areas tool
+*/
+const findUncoveredFailureAreasInputSchema = {
+	projectId: z.string().describe("Project ID to analyze. Required. Use list_projects to find project IDs."),
+	days: z.number().int().min(1).max(365).optional().describe("Number of days to analyze for test failures (default: 30)"),
+	coverageThreshold: z.number().min(0).max(100).optional().describe("Include files with coverage below this percentage (default: 80)")
 };
-var findUncoveredFailureAreasOutputSchema = {
-  hasCoverage: z2.boolean(),
-  hasTestResults: z2.boolean(),
-  riskAreas: z2.array(z2.object({
-    filePath: z2.string(),
-    coverage: z2.number(),
-    failureCount: z2.number(),
-    riskScore: z2.number(),
-    testNames: z2.array(z2.string())
-  })),
-  message: z2.string().optional()
+/**
+* Output schema for find_uncovered_failure_areas tool
+*/
+const findUncoveredFailureAreasOutputSchema = {
+	hasCoverage: z.boolean(),
+	hasTestResults: z.boolean(),
+	riskAreas: z.array(z.object({
+		filePath: z.string(),
+		coverage: z.number(),
+		failureCount: z.number(),
+		riskScore: z.number(),
+		testNames: z.array(z.string())
+	})),
+	message: z.string().optional()
 };
+/**
+* Execute find_uncovered_failure_areas tool
+*/
 async function executeFindUncoveredFailureAreas(client, input) {
-  const response = await client.getCoverageRiskAreas({
-    projectId: input.projectId,
-    days: input.days,
-    coverageThreshold: input.coverageThreshold
-  });
-  return {
-    hasCoverage: response.hasCoverage,
-    hasTestResults: response.hasTestResults,
-    riskAreas: response.riskAreas,
-    message: response.message
-  };
+	const response = await client.getCoverageRiskAreas({
+		projectId: input.projectId,
+		days: input.days,
+		coverageThreshold: input.coverageThreshold
+	});
+	return {
+		hasCoverage: response.hasCoverage,
+		hasTestResults: response.hasTestResults,
+		riskAreas: response.riskAreas,
+		message: response.message
+	};
 }
-var findUncoveredFailureAreasMetadata = {
-  name: "find_uncovered_failure_areas",
-  title: "Find Uncovered Failure Areas",
-  description: `Find areas of code that have both low coverage AND test failures.
+/**
+* Tool metadata
+*/
+const findUncoveredFailureAreasMetadata = {
+	name: "find_uncovered_failure_areas",
+	title: "Find Uncovered Failure Areas",
+	description: `Find areas of code that have both low coverage AND test failures.
 
 This cross-references test failures with coverage data to identify high-risk
 areas in your codebase that need attention. Files are ranked by a "risk score"
-calculated as: (100 - coverage%) \xD7 failureCount.
+calculated as: (100 - coverage%) × failureCount.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -605,56 +618,67 @@ Returns:
 Use this to prioritize which parts of your codebase need better test coverage.`
 };
 
-// src/tools/get-coverage-for-file.ts
-import { z as z3 } from "zod";
-var getCoverageForFileInputSchema = {
-  projectId: z3.string().describe("Project ID to get coverage for. Required. Use list_projects to find project IDs."),
-  filePath: z3.string().describe("File path to get coverage for. Can be exact path or partial match.")
+//#endregion
+//#region src/tools/get-coverage-for-file.ts
+/**
+* Input schema for get_coverage_for_file tool
+*/
+const getCoverageForFileInputSchema = {
+	projectId: z.string().describe("Project ID to get coverage for. Required. Use list_projects to find project IDs."),
+	filePath: z.string().describe("File path to get coverage for. Can be exact path or partial match.")
 };
-var getCoverageForFileOutputSchema = {
-  hasCoverage: z3.boolean(),
-  files: z3.array(z3.object({
-    path: z3.string(),
-    lines: z3.object({
-      covered: z3.number(),
-      total: z3.number(),
-      percentage: z3.number()
-    }),
-    branches: z3.object({
-      covered: z3.number(),
-      total: z3.number(),
-      percentage: z3.number()
-    }),
-    functions: z3.object({
-      covered: z3.number(),
-      total: z3.number(),
-      percentage: z3.number()
-    })
-  })),
-  message: z3.string().optional()
+/**
+* Output schema for get_coverage_for_file tool
+*/
+const getCoverageForFileOutputSchema = {
+	hasCoverage: z.boolean(),
+	files: z.array(z.object({
+		path: z.string(),
+		lines: z.object({
+			covered: z.number(),
+			total: z.number(),
+			percentage: z.number()
+		}),
+		branches: z.object({
+			covered: z.number(),
+			total: z.number(),
+			percentage: z.number()
+		}),
+		functions: z.object({
+			covered: z.number(),
+			total: z.number(),
+			percentage: z.number()
+		})
+	})),
+	message: z.string().optional()
 };
+/**
+* Execute get_coverage_for_file tool
+*/
 async function executeGetCoverageForFile(client, input) {
-  const response = await client.getCoverageFiles({
-    projectId: input.projectId,
-    filePath: input.filePath,
-    limit: 10
-    // Return up to 10 matching files
-  });
-  return {
-    hasCoverage: response.hasCoverage,
-    files: response.files.map((f) => ({
-      path: f.path,
-      lines: f.lines,
-      branches: f.branches,
-      functions: f.functions
-    })),
-    message: response.message
-  };
+	const response = await client.getCoverageFiles({
+		projectId: input.projectId,
+		filePath: input.filePath,
+		limit: 10
+	});
+	return {
+		hasCoverage: response.hasCoverage,
+		files: response.files.map((f) => ({
+			path: f.path,
+			lines: f.lines,
+			branches: f.branches,
+			functions: f.functions
+		})),
+		message: response.message
+	};
 }
-var getCoverageForFileMetadata = {
-  name: "get_coverage_for_file",
-  title: "Get Coverage for File",
-  description: `Get coverage metrics for a specific file or files matching a path pattern.
+/**
+* Tool metadata
+*/
+const getCoverageForFileMetadata = {
+	name: "get_coverage_for_file",
+	title: "Get Coverage for File",
+	description: `Get coverage metrics for a specific file or files matching a path pattern.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -680,50 +704,66 @@ heavily-imported files, and code handling auth/payments/data mutations.
 Prioritize: high utilization + low coverage = highest impact.`
 };
 
-// src/tools/get-coverage-summary.ts
-import { z as z4 } from "zod";
-var getCoverageSummaryInputSchema = {
-  projectId: z4.string().describe("Project ID to get coverage for. Required. Use list_projects to find project IDs."),
-  days: z4.number().int().min(1).max(365).optional().describe("Number of days to analyze for trends (default: 30)")
+//#endregion
+//#region src/tools/get-coverage-summary.ts
+/**
+* Input schema for get_coverage_summary tool
+*/
+const getCoverageSummaryInputSchema = {
+	projectId: z.string().describe("Project ID to get coverage for. Required. Use list_projects to find project IDs."),
+	days: z.number().int().min(1).max(365).optional().describe("Number of days to analyze for trends (default: 30)")
 };
-var getCoverageSummaryOutputSchema = {
-  hasCoverage: z4.boolean(),
-  current: z4.object({
-    lines: z4.number(),
-    branches: z4.number(),
-    functions: z4.number()
-  }).optional(),
-  trend: z4.object({
-    direction: z4.enum(["up", "down", "stable"]),
-    change: z4.number()
-  }).optional(),
-  totalReports: z4.number(),
-  latestReportDate: z4.string().nullable().optional(),
-  lowestCoverageFiles: z4.array(z4.object({
-    path: z4.string(),
-    coverage: z4.number()
-  })).optional(),
-  message: z4.string().optional()
+/**
+* Output schema for get_coverage_summary tool
+*/
+const getCoverageSummaryOutputSchema = {
+	hasCoverage: z.boolean(),
+	current: z.object({
+		lines: z.number(),
+		branches: z.number(),
+		functions: z.number()
+	}).optional(),
+	trend: z.object({
+		direction: z.enum([
+			"up",
+			"down",
+			"stable"
+		]),
+		change: z.number()
+	}).optional(),
+	totalReports: z.number(),
+	latestReportDate: z.string().nullable().optional(),
+	lowestCoverageFiles: z.array(z.object({
+		path: z.string(),
+		coverage: z.number()
+	})).optional(),
+	message: z.string().optional()
 };
+/**
+* Execute get_coverage_summary tool
+*/
 async function executeGetCoverageSummary(client, input) {
-  const response = await client.getCoverageSummary({
-    projectId: input.projectId,
-    days: input.days
-  });
-  return {
-    hasCoverage: response.hasCoverage,
-    current: response.current,
-    trend: response.trend,
-    totalReports: response.totalReports,
-    latestReportDate: response.latestReportDate,
-    lowestCoverageFiles: response.lowestCoverageFiles,
-    message: response.message
-  };
+	const response = await client.getCoverageSummary({
+		projectId: input.projectId,
+		days: input.days
+	});
+	return {
+		hasCoverage: response.hasCoverage,
+		current: response.current,
+		trend: response.trend,
+		totalReports: response.totalReports,
+		latestReportDate: response.latestReportDate,
+		lowestCoverageFiles: response.lowestCoverageFiles,
+		message: response.message
+	};
 }
-var getCoverageSummaryMetadata = {
-  name: "get_coverage_summary",
-  title: "Get Coverage Summary",
-  description: `Get the coverage metrics summary for a project.
+/**
+* Tool metadata
+*/
+const getCoverageSummaryMetadata = {
+	name: "get_coverage_summary",
+	title: "Get Coverage Summary",
+	description: `Get the coverage metrics summary for a project.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -742,44 +782,127 @@ specific areas (e.g., "server/services", "src/api", "lib/core"). This helps iden
 high-value targets in critical code paths rather than just the files with lowest coverage.`
 };
 
-// src/tools/get-flaky-tests.ts
-import { z as z5 } from "zod";
-var getFlakyTestsInputSchema = {
-  projectId: z5.string().optional().describe("Project ID to get flaky tests for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
-  threshold: z5.number().min(0).max(1).optional().describe("Minimum flip rate to be considered flaky (0-1, default: 0.1 = 10%)"),
-  limit: z5.number().int().min(1).max(100).optional().describe("Maximum number of flaky tests to return (default: 50)"),
-  days: z5.number().int().min(1).max(365).optional().describe("Analysis period in days (default: 30)")
+//#endregion
+//#region src/tools/get-failure-clusters.ts
+/**
+* Input schema for get_failure_clusters tool
+*/
+const getFailureClustersInputSchema = {
+	projectId: z.string().describe("Project ID. Use list_projects to find project IDs."),
+	testRunId: z.string().describe("Test run ID to get failure clusters for. Use list_test_runs to find test run IDs.")
+};
+/**
+* Output schema for get_failure_clusters tool
+*/
+const getFailureClustersOutputSchema = {
+	clusters: z.array(z.object({
+		representativeError: z.string(),
+		count: z.number(),
+		tests: z.array(z.object({
+			name: z.string(),
+			fullName: z.string(),
+			errorMessage: z.string(),
+			filePath: z.string().nullable()
+		})),
+		similarity: z.number()
+	})),
+	totalFailures: z.number()
 };
-var getFlakyTestsOutputSchema = {
-  flakyTests: z5.array(z5.object({
-    name: z5.string(),
-    flipRate: z5.number(),
-    flipCount: z5.number(),
-    totalRuns: z5.number(),
-    lastSeen: z5.string()
-  })),
-  summary: z5.object({
-    threshold: z5.number(),
-    totalFlaky: z5.number(),
-    period: z5.number()
-  })
+/**
+* Execute get_failure_clusters tool
+*/
+async function executeGetFailureClusters(client, input) {
+	return client.getFailureClusters({
+		projectId: input.projectId,
+		testRunId: input.testRunId
+	});
+}
+/**
+* Tool metadata
+*/
+const getFailureClustersMetadata = {
+	name: "get_failure_clusters",
+	title: "Get Failure Clusters",
+	description: `Group failed tests by root cause using error message similarity.
+
+When using a user API Key (gaf_), you must provide a projectId.
+Use list_projects to find available project IDs, and list_test_runs to find test run IDs.
+
+Parameters:
+- projectId (required): The project ID
+- testRunId (required): The test run ID to analyze
+
+Returns:
+- clusters: Array of failure clusters, each containing:
+  - representativeError: The error message representing this cluster
+  - count: Number of tests with this same root cause
+  - tests: Array of individual failed tests in this cluster
+    - name: Short test name
+    - fullName: Full test name including describe blocks
+    - errorMessage: The specific error message
+    - filePath: Test file path (null if not recorded)
+  - similarity: Similarity threshold used for clustering (0-1)
+- totalFailures: Total number of failed tests across all clusters
+
+Use cases:
+- "Group these 15 failures by root cause" — often reveals 2-3 distinct bugs
+- "Which error affects the most tests?" — fix the largest cluster first
+- "Are these failures related?" — check if they land in the same cluster
+
+Tip: Use get_test_run_details with status='failed' first to see raw failures,
+then use this tool to understand which failures share the same root cause.`
 };
+
+//#endregion
+//#region src/tools/get-flaky-tests.ts
+/**
+* Input schema for get_flaky_tests tool
+*/
+const getFlakyTestsInputSchema = {
+	projectId: z.string().optional().describe("Project ID to get flaky tests for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
+	threshold: z.number().min(0).max(1).optional().describe("Minimum flip rate to be considered flaky (0-1, default: 0.1 = 10%)"),
+	limit: z.number().int().min(1).max(100).optional().describe("Maximum number of flaky tests to return (default: 50)"),
+	days: z.number().int().min(1).max(365).optional().describe("Analysis period in days (default: 30)")
+};
+/**
+* Output schema for get_flaky_tests tool
+*/
+const getFlakyTestsOutputSchema = {
+	flakyTests: z.array(z.object({
+		name: z.string(),
+		flipRate: z.number(),
+		flipCount: z.number(),
+		totalRuns: z.number(),
+		lastSeen: z.string()
+	})),
+	summary: z.object({
+		threshold: z.number(),
+		totalFlaky: z.number(),
+		period: z.number()
+	})
+};
+/**
+* Execute get_flaky_tests tool
+*/
 async function executeGetFlakyTests(client, input) {
-  const response = await client.getFlakyTests({
-    projectId: input.projectId,
-    threshold: input.threshold,
-    limit: input.limit,
-    days: input.days
-  });
-  return {
-    flakyTests: response.flakyTests,
-    summary: response.summary
-  };
+	const response = await client.getFlakyTests({
+		projectId: input.projectId,
+		threshold: input.threshold,
+		limit: input.limit,
+		days: input.days
+	});
+	return {
+		flakyTests: response.flakyTests,
+		summary: response.summary
+	};
 }
-var getFlakyTestsMetadata = {
-  name: "get_flaky_tests",
-  title: "Get Flaky Tests",
-  description: `Get the list of flaky tests in a project.
+/**
+* Tool metadata
+*/
+const getFlakyTestsMetadata = {
+	name: "get_flaky_tests",
+	title: "Get Flaky Tests",
+	description: `Get the list of flaky tests in a project.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -800,44 +923,60 @@ Use this after get_project_health shows flaky tests exist, to identify which
 specific tests are flaky and need investigation.`
 };
 
-// src/tools/get-project-health.ts
-import { z as z6 } from "zod";
-var getProjectHealthInputSchema = {
-  projectId: z6.string().optional().describe("Project ID to get health for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
-  days: z6.number().int().min(1).max(365).optional().describe("Number of days to analyze (default: 30)")
+//#endregion
+//#region src/tools/get-project-health.ts
+/**
+* Input schema for get_project_health tool
+*/
+const getProjectHealthInputSchema = {
+	projectId: z.string().optional().describe("Project ID to get health for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
+	days: z.number().int().min(1).max(365).optional().describe("Number of days to analyze (default: 30)")
 };
-var getProjectHealthOutputSchema = {
-  projectName: z6.string(),
-  healthScore: z6.number(),
-  passRate: z6.number().nullable(),
-  testRunCount: z6.number(),
-  flakyTestCount: z6.number(),
-  trend: z6.enum(["up", "down", "stable"]),
-  period: z6.object({
-    days: z6.number(),
-    start: z6.string(),
-    end: z6.string()
-  })
+/**
+* Output schema for get_project_health tool
+*/
+const getProjectHealthOutputSchema = {
+	projectName: z.string(),
+	healthScore: z.number(),
+	passRate: z.number().nullable(),
+	testRunCount: z.number(),
+	flakyTestCount: z.number(),
+	trend: z.enum([
+		"up",
+		"down",
+		"stable"
+	]),
+	period: z.object({
+		days: z.number(),
+		start: z.string(),
+		end: z.string()
+	})
 };
+/**
+* Execute get_project_health tool
+*/
 async function executeGetProjectHealth(client, input) {
-  const response = await client.getProjectHealth({
-    projectId: input.projectId,
-    days: input.days
-  });
-  return {
-    projectName: response.analytics.projectName,
-    healthScore: response.analytics.healthScore,
-    passRate: response.analytics.passRate,
-    testRunCount: response.analytics.testRunCount,
-    flakyTestCount: response.analytics.flakyTestCount,
-    trend: response.analytics.trend,
-    period: response.analytics.period
-  };
+	const response = await client.getProjectHealth({
+		projectId: input.projectId,
+		days: input.days
+	});
+	return {
+		projectName: response.analytics.projectName,
+		healthScore: response.analytics.healthScore,
+		passRate: response.analytics.passRate,
+		testRunCount: response.analytics.testRunCount,
+		flakyTestCount: response.analytics.flakyTestCount,
+		trend: response.analytics.trend,
+		period: response.analytics.period
+	};
 }
-var getProjectHealthMetadata = {
-  name: "get_project_health",
-  title: "Get Project Health",
-  description: `Get the health metrics for a project.
+/**
+* Tool metadata
+*/
+const getProjectHealthMetadata = {
+	name: "get_project_health",
+	title: "Get Project Health",
+	description: `Get the health metrics for a project.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -852,38 +991,50 @@ Returns:
 Use this to understand the current state of your test suite.`
 };
 
-// src/tools/get-report-browser-url.ts
-import { z as z7 } from "zod";
-var getReportBrowserUrlInputSchema = {
-  projectId: z7.string().describe("Project ID the test run belongs to. Required. Use list_projects to find project IDs."),
-  testRunId: z7.string().describe("The test run ID to get the report URL for. Use list_test_runs to find test run IDs."),
-  filename: z7.string().optional().describe("Specific file to open (default: index.html or first HTML file)")
+//#endregion
+//#region src/tools/get-report-browser-url.ts
+/**
+* Input schema for get_report_browser_url tool
+*/
+const getReportBrowserUrlInputSchema = {
+	projectId: z.string().describe("Project ID the test run belongs to. Required. Use list_projects to find project IDs."),
+	testRunId: z.string().describe("The test run ID to get the report URL for. Use list_test_runs to find test run IDs."),
+	filename: z.string().optional().describe("Specific file to open (default: index.html or first HTML file)")
 };
-var getReportBrowserUrlOutputSchema = {
-  url: z7.string(),
-  filename: z7.string(),
-  testRunId: z7.string(),
-  expiresAt: z7.string(),
-  expiresInSeconds: z7.number()
+/**
+* Output schema for get_report_browser_url tool
+*/
+const getReportBrowserUrlOutputSchema = {
+	url: z.string(),
+	filename: z.string(),
+	testRunId: z.string(),
+	expiresAt: z.string(),
+	expiresInSeconds: z.number()
 };
+/**
+* Execute get_report_browser_url tool
+*/
 async function executeGetReportBrowserUrl(client, input) {
-  const response = await client.getReportBrowserUrl({
-    projectId: input.projectId,
-    testRunId: input.testRunId,
-    filename: input.filename
-  });
-  return {
-    url: response.url,
-    filename: response.filename,
-    testRunId: response.testRunId,
-    expiresAt: response.expiresAt,
-    expiresInSeconds: response.expiresInSeconds
-  };
+	const response = await client.getReportBrowserUrl({
+		projectId: input.projectId,
+		testRunId: input.testRunId,
+		filename: input.filename
+	});
+	return {
+		url: response.url,
+		filename: response.filename,
+		testRunId: response.testRunId,
+		expiresAt: response.expiresAt,
+		expiresInSeconds: response.expiresInSeconds
+	};
 }
-var getReportBrowserUrlMetadata = {
-  name: "get_report_browser_url",
-  title: "Get Report Browser URL",
-  description: `Get a browser-navigable URL for viewing a test report (Playwright, Vitest, etc.).
+/**
+* Tool metadata
+*/
+const getReportBrowserUrlMetadata = {
+	name: "get_report_browser_url",
+	title: "Get Report Browser URL",
+	description: `Get a browser-navigable URL for viewing a test report (Playwright, Vitest, etc.).
 
 Returns a signed URL that can be opened directly in a browser without requiring
 the user to log in. The URL expires after 30 minutes for security.
@@ -906,44 +1057,54 @@ The returned URL can be shared with users who need to view the report.
 Note: URLs expire after 30 minutes for security.`
 };
 
-// src/tools/get-report.ts
-import { z as z8 } from "zod";
-var getReportInputSchema = {
-  testRunId: z8.string().describe("The test run ID to get report files for. Use list_test_runs to find test run IDs.")
-};
-var getReportOutputSchema = {
-  testRunId: z8.string(),
-  projectId: z8.string(),
-  projectName: z8.string(),
-  resultSchema: z8.string().optional(),
-  files: z8.array(z8.object({
-    filename: z8.string(),
-    size: z8.number(),
-    contentType: z8.string(),
-    downloadUrl: z8.string()
-  })),
-  urlExpiresInSeconds: z8.number().optional()
+//#endregion
+//#region src/tools/get-report.ts
+/**
+* Input schema for get_report tool
+*/
+const getReportInputSchema = { testRunId: z.string().describe("The test run ID to get report files for. Use list_test_runs to find test run IDs.") };
+/**
+* Output schema for get_report tool
+*/
+const getReportOutputSchema = {
+	testRunId: z.string(),
+	projectId: z.string(),
+	projectName: z.string(),
+	resultSchema: z.string().optional(),
+	files: z.array(z.object({
+		filename: z.string(),
+		size: z.number(),
+		contentType: z.string(),
+		downloadUrl: z.string()
+	})),
+	urlExpiresInSeconds: z.number().optional()
 };
+/**
+* Execute get_report tool
+*/
 async function executeGetReport(client, input) {
-  const response = await client.getReport(input.testRunId);
-  return {
-    testRunId: response.testRunId,
-    projectId: response.projectId,
-    projectName: response.projectName,
-    resultSchema: response.resultSchema,
-    files: response.files.map((file) => ({
-      filename: file.filename,
-      size: file.size,
-      contentType: file.contentType,
-      downloadUrl: file.downloadUrl
-    })),
-    urlExpiresInSeconds: response.urlExpiresInSeconds
-  };
+	const response = await client.getReport(input.testRunId);
+	return {
+		testRunId: response.testRunId,
+		projectId: response.projectId,
+		projectName: response.projectName,
+		resultSchema: response.resultSchema,
+		files: response.files.map((file) => ({
+			filename: file.filename,
+			size: file.size,
+			contentType: file.contentType,
+			downloadUrl: file.downloadUrl
+		})),
+		urlExpiresInSeconds: response.urlExpiresInSeconds
+	};
 }
-var getReportMetadata = {
-  name: "get_report",
-  title: "Get Report Files",
-  description: `Get URLs for report files uploaded with a test run.
+/**
+* Tool metadata
+*/
+const getReportMetadata = {
+	name: "get_report",
+	title: "Get Report Files",
+	description: `Get URLs for report files uploaded with a test run.
 
 IMPORTANT: This tool returns download URLs, not file content. You must fetch the URLs separately.
 
@@ -979,57 +1140,69 @@ Use cases:
 - "Parse the JUnit XML results" (then WebFetch the XML URL)`
 };
 
-// src/tools/get-slowest-tests.ts
-import { z as z9 } from "zod";
-var getSlowestTestsInputSchema = {
-  projectId: z9.string().describe("Project ID to get slowest tests for. Required. Use list_projects to find project IDs."),
-  days: z9.number().int().min(1).max(365).optional().describe("Analysis period in days (default: 30)"),
-  limit: z9.number().int().min(1).max(100).optional().describe("Maximum number of tests to return (default: 20)"),
-  framework: z9.string().optional().describe('Filter by test framework (e.g., "playwright", "vitest", "jest")'),
-  branch: z9.string().optional().describe('Filter by git branch name (e.g., "main", "develop")')
+//#endregion
+//#region src/tools/get-slowest-tests.ts
+/**
+* Input schema for get_slowest_tests tool
+*/
+const getSlowestTestsInputSchema = {
+	projectId: z.string().describe("Project ID to get slowest tests for. Required. Use list_projects to find project IDs."),
+	days: z.number().int().min(1).max(365).optional().describe("Analysis period in days (default: 30)"),
+	limit: z.number().int().min(1).max(100).optional().describe("Maximum number of tests to return (default: 20)"),
+	framework: z.string().optional().describe("Filter by test framework (e.g., \"playwright\", \"vitest\", \"jest\")"),
+	branch: z.string().optional().describe("Filter by git branch name (e.g., \"main\", \"develop\")")
 };
-var getSlowestTestsOutputSchema = {
-  slowestTests: z9.array(z9.object({
-    name: z9.string(),
-    fullName: z9.string(),
-    filePath: z9.string().optional(),
-    framework: z9.string().optional(),
-    avgDurationMs: z9.number(),
-    p95DurationMs: z9.number(),
-    runCount: z9.number()
-  })),
-  summary: z9.object({
-    projectId: z9.string(),
-    projectName: z9.string(),
-    period: z9.number(),
-    totalReturned: z9.number()
-  })
+/**
+* Output schema for get_slowest_tests tool
+*/
+const getSlowestTestsOutputSchema = {
+	slowestTests: z.array(z.object({
+		name: z.string(),
+		fullName: z.string(),
+		filePath: z.string().optional(),
+		framework: z.string().optional(),
+		avgDurationMs: z.number(),
+		p95DurationMs: z.number(),
+		runCount: z.number()
+	})),
+	summary: z.object({
+		projectId: z.string(),
+		projectName: z.string(),
+		period: z.number(),
+		totalReturned: z.number()
+	})
 };
+/**
+* Execute get_slowest_tests tool
+*/
 async function executeGetSlowestTests(client, input) {
-  const response = await client.getSlowestTests({
-    projectId: input.projectId,
-    days: input.days,
-    limit: input.limit,
-    framework: input.framework,
-    branch: input.branch
-  });
-  return {
-    slowestTests: response.slowestTests.map((test) => ({
-      name: test.name,
-      fullName: test.fullName,
-      filePath: test.filePath,
-      framework: test.framework,
-      avgDurationMs: test.avgDurationMs,
-      p95DurationMs: test.p95DurationMs,
-      runCount: test.runCount
-    })),
-    summary: response.summary
-  };
+	const response = await client.getSlowestTests({
+		projectId: input.projectId,
+		days: input.days,
+		limit: input.limit,
+		framework: input.framework,
+		branch: input.branch
+	});
+	return {
+		slowestTests: response.slowestTests.map((test) => ({
+			name: test.name,
+			fullName: test.fullName,
+			filePath: test.filePath,
+			framework: test.framework,
+			avgDurationMs: test.avgDurationMs,
+			p95DurationMs: test.p95DurationMs,
+			runCount: test.runCount
+		})),
+		summary: response.summary
+	};
 }
-var getSlowestTestsMetadata = {
-  name: "get_slowest_tests",
-  title: "Get Slowest Tests",
-  description: `Get the slowest tests in a project, sorted by P95 duration.
+/**
+* Tool metadata
+*/
+const getSlowestTestsMetadata = {
+	name: "get_slowest_tests",
+	title: "Get Slowest Tests",
+	description: `Get the slowest tests in a project, sorted by P95 duration.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -1059,64 +1232,78 @@ Use cases:
 - "What are the slowest tests on the main branch?"`
 };
 
-// src/tools/get-test-history.ts
-import { z as z10 } from "zod";
-var getTestHistoryInputSchema = {
-  projectId: z10.string().optional().describe("Project ID to get test history for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
-  testName: z10.string().optional().describe("Exact test name to search for"),
-  filePath: z10.string().optional().describe("File path containing the test"),
-  limit: z10.number().int().min(1).max(100).optional().describe("Maximum number of results (default: 20)")
+//#endregion
+//#region src/tools/get-test-history.ts
+/**
+* Input schema for get_test_history tool
+*/
+const getTestHistoryInputSchema = {
+	projectId: z.string().optional().describe("Project ID to get test history for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
+	testName: z.string().optional().describe("Exact test name to search for"),
+	filePath: z.string().optional().describe("File path containing the test"),
+	limit: z.number().int().min(1).max(100).optional().describe("Maximum number of results (default: 20)")
 };
-var getTestHistoryOutputSchema = {
-  history: z10.array(z10.object({
-    testRunId: z10.string(),
-    createdAt: z10.string(),
-    branch: z10.string().optional(),
-    commitSha: z10.string().optional(),
-    status: z10.enum(["passed", "failed", "skipped", "pending"]),
-    durationMs: z10.number(),
-    message: z10.string().optional()
-  })),
-  summary: z10.object({
-    totalRuns: z10.number(),
-    passedRuns: z10.number(),
-    failedRuns: z10.number(),
-    passRate: z10.number().nullable()
-  })
+/**
+* Output schema for get_test_history tool
+*/
+const getTestHistoryOutputSchema = {
+	history: z.array(z.object({
+		testRunId: z.string(),
+		createdAt: z.string(),
+		branch: z.string().optional(),
+		commitSha: z.string().optional(),
+		status: z.enum([
+			"passed",
+			"failed",
+			"skipped",
+			"pending"
+		]),
+		durationMs: z.number(),
+		message: z.string().optional()
+	})),
+	summary: z.object({
+		totalRuns: z.number(),
+		passedRuns: z.number(),
+		failedRuns: z.number(),
+		passRate: z.number().nullable()
+	})
 };
+/**
+* Execute get_test_history tool
+*/
 async function executeGetTestHistory(client, input) {
-  if (!input.testName && !input.filePath) {
-    throw new Error("Either testName or filePath is required");
-  }
-  const response = await client.getTestHistory({
-    projectId: input.projectId,
-    testName: input.testName,
-    filePath: input.filePath,
-    limit: input.limit || 20
-  });
-  return {
-    history: response.history.map((entry) => ({
-      testRunId: entry.testRunId,
-      createdAt: entry.createdAt,
-      branch: entry.branch,
-      commitSha: entry.commitSha,
-      status: entry.test.status,
-      durationMs: entry.test.durationMs,
-      message: entry.test.message || void 0
-      // Convert null to undefined for schema compliance
-    })),
-    summary: {
-      totalRuns: response.summary.totalRuns,
-      passedRuns: response.summary.passedRuns,
-      failedRuns: response.summary.failedRuns,
-      passRate: response.summary.passRate
-    }
-  };
+	if (!input.testName && !input.filePath) throw new Error("Either testName or filePath is required");
+	const response = await client.getTestHistory({
+		projectId: input.projectId,
+		testName: input.testName,
+		filePath: input.filePath,
+		limit: input.limit || 20
+	});
+	return {
+		history: response.history.map((entry) => ({
+			testRunId: entry.testRunId,
+			createdAt: entry.createdAt,
+			branch: entry.branch,
+			commitSha: entry.commitSha,
+			status: entry.test.status,
+			durationMs: entry.test.durationMs,
+			message: entry.test.message || void 0
+		})),
+		summary: {
+			totalRuns: response.summary.totalRuns,
+			passedRuns: response.summary.passedRuns,
+			failedRuns: response.summary.failedRuns,
+			passRate: response.summary.passRate
+		}
+	};
 }
-var getTestHistoryMetadata = {
-  name: "get_test_history",
-  title: "Get Test History",
-  description: `Get the pass/fail history for a specific test.
+/**
+* Tool metadata
+*/
+const getTestHistoryMetadata = {
+	name: "get_test_history",
+	title: "Get Test History",
+	description: `Get the pass/fail history for a specific test.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -1135,57 +1322,86 @@ Returns:
 Use this to investigate flaky tests or understand test stability.`
 };
 
-// src/tools/get-test-run-details.ts
-import { z as z11 } from "zod";
-var getTestRunDetailsInputSchema = {
-  testRunId: z11.string().describe("The test run ID to get details for. Use list_test_runs to find test run IDs."),
-  projectId: z11.string().describe("Project ID the test run belongs to. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
-  status: z11.enum(["passed", "failed", "skipped"]).optional().describe("Filter tests by status. Returns only tests matching this status."),
-  limit: z11.number().int().min(1).max(500).optional().describe("Maximum number of tests to return (default: 100, max: 500)"),
-  offset: z11.number().int().min(0).optional().describe("Number of tests to skip for pagination (default: 0)")
+//#endregion
+//#region src/tools/get-test-run-details.ts
+/**
+* Input schema for get_test_run_details tool
+*/
+const getTestRunDetailsInputSchema = {
+	testRunId: z.string().describe("The test run ID to get details for. Use list_test_runs to find test run IDs."),
+	projectId: z.string().describe("Project ID the test run belongs to. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
+	status: z.enum([
+		"passed",
+		"failed",
+		"skipped"
+	]).optional().describe("Filter tests by status. Returns only tests matching this status."),
+	limit: z.number().int().min(1).max(500).optional().describe("Maximum number of tests to return (default: 100, max: 500)"),
+	offset: z.number().int().min(0).optional().describe("Number of tests to skip for pagination (default: 0)")
 };
-var getTestRunDetailsOutputSchema = {
-  testRunId: z11.string(),
-  summary: z11.object({
-    passed: z11.number(),
-    failed: z11.number(),
-    skipped: z11.number(),
-    total: z11.number()
-  }),
-  tests: z11.array(z11.object({
-    name: z11.string(),
-    fullName: z11.string(),
-    status: z11.enum(["passed", "failed", "skipped"]),
-    durationMs: z11.number().nullable(),
-    filePath: z11.string().nullable(),
-    error: z11.string().nullable()
-  })),
-  pagination: z11.object({
-    total: z11.number(),
-    limit: z11.number(),
-    offset: z11.number(),
-    hasMore: z11.boolean()
-  })
+/**
+* Output schema for get_test_run_details tool
+*/
+const getTestRunDetailsOutputSchema = {
+	testRunId: z.string(),
+	commitSha: z.string().nullable(),
+	branch: z.string().nullable(),
+	framework: z.string().nullable(),
+	createdAt: z.string(),
+	summary: z.object({
+		passed: z.number(),
+		failed: z.number(),
+		skipped: z.number(),
+		total: z.number()
+	}),
+	tests: z.array(z.object({
+		name: z.string(),
+		fullName: z.string(),
+		status: z.enum([
+			"passed",
+			"failed",
+			"skipped"
+		]),
+		durationMs: z.number().nullable(),
+		filePath: z.string().nullable(),
+		error: z.string().nullable(),
+		errorStack: z.string().nullable()
+	})),
+	pagination: z.object({
+		total: z.number(),
+		limit: z.number(),
+		offset: z.number(),
+		hasMore: z.boolean()
+	})
 };
+/**
+* Execute get_test_run_details tool
+*/
 async function executeGetTestRunDetails(client, input) {
-  const response = await client.getTestRunDetails({
-    projectId: input.projectId,
-    testRunId: input.testRunId,
-    status: input.status,
-    limit: input.limit,
-    offset: input.offset
-  });
-  return {
-    testRunId: response.testRunId,
-    summary: response.summary,
-    tests: response.tests,
-    pagination: response.pagination
-  };
+	const response = await client.getTestRunDetails({
+		projectId: input.projectId,
+		testRunId: input.testRunId,
+		status: input.status,
+		limit: input.limit,
+		offset: input.offset
+	});
+	return {
+		testRunId: response.testRunId,
+		commitSha: response.commitSha,
+		branch: response.branch,
+		framework: response.framework,
+		createdAt: response.createdAt,
+		summary: response.summary,
+		tests: response.tests,
+		pagination: response.pagination
+	};
 }
-var getTestRunDetailsMetadata = {
-  name: "get_test_run_details",
-  title: "Get Test Run Details",
-  description: `Get parsed test results for a specific test run.
+/**
+* Tool metadata
+*/
+const getTestRunDetailsMetadata = {
+	name: "get_test_run_details",
+	title: "Get Test Run Details",
+	description: `Get parsed test results for a specific test run.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects to find available project IDs, and list_test_runs to find test run IDs.
@@ -1199,6 +1415,10 @@ Parameters:
 
 Returns:
 - testRunId: The test run ID
+- commitSha: Git commit SHA (null if not recorded)
+- branch: Git branch name (null if not recorded)
+- framework: Test framework (e.g., "playwright", "vitest")
+- createdAt: When the test run was created (ISO 8601)
 - summary: Overall counts (passed, failed, skipped, total)
 - tests: Array of individual test results with:
   - name: Short test name
@@ -1207,6 +1427,7 @@ Returns:
   - durationMs: Test duration in milliseconds (null if not recorded)
   - filePath: Test file path (null if not recorded)
   - error: Error message for failed tests (null otherwise)
+  - errorStack: Full stack trace for failed tests (null otherwise)
 - pagination: Pagination info (total, limit, offset, hasMore)
 
 Use cases:
@@ -1219,63 +1440,74 @@ Note: For aggregate analytics like flaky test detection or duration trends,
 use get_test_history, get_flaky_tests, or get_slowest_tests instead.`
 };
 
-// src/tools/get-untested-files.ts
-import { z as z12 } from "zod";
-var getUntestedFilesInputSchema = {
-  projectId: z12.string().describe("Project ID to analyze. Required. Use list_projects to find project IDs."),
-  maxCoverage: z12.number().min(0).max(100).optional().describe('Maximum coverage percentage to include (default: 10 for "untested")'),
-  limit: z12.number().int().min(1).max(100).optional().describe("Maximum number of files to return (default: 20)")
+//#endregion
+//#region src/tools/get-untested-files.ts
+/**
+* Input schema for get_untested_files tool
+*/
+const getUntestedFilesInputSchema = {
+	projectId: z.string().describe("Project ID to analyze. Required. Use list_projects to find project IDs."),
+	maxCoverage: z.number().min(0).max(100).optional().describe("Maximum coverage percentage to include (default: 10 for \"untested\")"),
+	limit: z.number().int().min(1).max(100).optional().describe("Maximum number of files to return (default: 20)")
 };
-var getUntestedFilesOutputSchema = {
-  hasCoverage: z12.boolean(),
-  files: z12.array(z12.object({
-    path: z12.string(),
-    lines: z12.object({
-      covered: z12.number(),
-      total: z12.number(),
-      percentage: z12.number()
-    }),
-    branches: z12.object({
-      covered: z12.number(),
-      total: z12.number(),
-      percentage: z12.number()
-    }),
-    functions: z12.object({
-      covered: z12.number(),
-      total: z12.number(),
-      percentage: z12.number()
-    })
-  })),
-  totalCount: z12.number(),
-  message: z12.string().optional()
+/**
+* Output schema for get_untested_files tool
+*/
+const getUntestedFilesOutputSchema = {
+	hasCoverage: z.boolean(),
+	files: z.array(z.object({
+		path: z.string(),
+		lines: z.object({
+			covered: z.number(),
+			total: z.number(),
+			percentage: z.number()
+		}),
+		branches: z.object({
+			covered: z.number(),
+			total: z.number(),
+			percentage: z.number()
+		}),
+		functions: z.object({
+			covered: z.number(),
+			total: z.number(),
+			percentage: z.number()
+		})
+	})),
+	totalCount: z.number(),
+	message: z.string().optional()
 };
+/**
+* Execute get_untested_files tool
+*/
 async function executeGetUntestedFiles(client, input) {
-  const maxCoverage = input.maxCoverage ?? 10;
-  const limit = input.limit ?? 20;
-  const response = await client.getCoverageFiles({
-    projectId: input.projectId,
-    maxCoverage,
-    limit,
-    sortBy: "coverage",
-    sortOrder: "asc"
-    // Lowest coverage first
-  });
-  return {
-    hasCoverage: response.hasCoverage,
-    files: response.files.map((f) => ({
-      path: f.path,
-      lines: f.lines,
-      branches: f.branches,
-      functions: f.functions
-    })),
-    totalCount: response.pagination.total,
-    message: response.message
-  };
+	const maxCoverage = input.maxCoverage ?? 10;
+	const limit = input.limit ?? 20;
+	const response = await client.getCoverageFiles({
+		projectId: input.projectId,
+		maxCoverage,
+		limit,
+		sortBy: "coverage",
+		sortOrder: "asc"
+	});
+	return {
+		hasCoverage: response.hasCoverage,
+		files: response.files.map((f) => ({
+			path: f.path,
+			lines: f.lines,
+			branches: f.branches,
+			functions: f.functions
+		})),
+		totalCount: response.pagination.total,
+		message: response.message
+	};
 }
-var getUntestedFilesMetadata = {
-  name: "get_untested_files",
-  title: "Get Untested Files",
-  description: `Get files with little or no test coverage.
+/**
+* Tool metadata
+*/
+const getUntestedFilesMetadata = {
+	name: "get_untested_files",
+	title: "Get Untested Files",
+	description: `Get files with little or no test coverage.
 
 Returns files sorted by coverage percentage (lowest first), filtered
 to only include files below a coverage threshold.
@@ -1302,44 +1534,167 @@ To prioritize effectively, explore the codebase to understand which code is heav
 for those specific paths.`
 };
 
-// src/tools/list-projects.ts
-import { z as z13 } from "zod";
-var listProjectsInputSchema = {
-  organizationId: z13.string().optional().describe("Filter by organization ID (optional)"),
-  limit: z13.number().int().min(1).max(100).optional().describe("Maximum number of projects to return (default: 50)")
+//#endregion
+//#region src/tools/get-upload-status.ts
+/**
+* Input schema for get_upload_status tool
+*/
+const getUploadStatusInputSchema = {
+	projectId: z.string().describe("Project ID. Use list_projects to find project IDs."),
+	sessionId: z.string().optional().describe("Specific upload session ID. If provided, returns detailed status for that session. Otherwise, lists recent sessions."),
+	commitSha: z.string().optional().describe("Filter sessions by commit SHA. Useful for checking if results for a specific commit are ready."),
+	branch: z.string().optional().describe("Filter sessions by branch name.")
+};
+/**
+* Output schema for get_upload_status tool
+*/
+const getUploadStatusOutputSchema = {
+	sessions: z.array(z.object({
+		id: z.string(),
+		processingStatus: z.string(),
+		commitSha: z.string().nullable(),
+		branch: z.string().nullable(),
+		pendingFileCount: z.number(),
+		failedFileCount: z.number(),
+		createdAt: z.string(),
+		updatedAt: z.string()
+	})).optional(),
+	session: z.object({
+		id: z.string(),
+		processingStatus: z.string(),
+		commitSha: z.string().nullable(),
+		branch: z.string().nullable(),
+		createdAt: z.string()
+	}).optional(),
+	testRuns: z.array(z.object({
+		id: z.string(),
+		framework: z.string().nullable(),
+		summary: z.object({
+			passed: z.number(),
+			failed: z.number(),
+			skipped: z.number(),
+			total: z.number()
+		}),
+		createdAt: z.string()
+	})).optional(),
+	coverageReports: z.array(z.object({
+		id: z.string(),
+		format: z.string(),
+		createdAt: z.string()
+	})).optional(),
+	pagination: z.object({
+		total: z.number(),
+		limit: z.number(),
+		offset: z.number(),
+		hasMore: z.boolean()
+	}).optional()
+};
+/**
+* Execute get_upload_status tool
+*/
+async function executeGetUploadStatus(client, input) {
+	if (input.sessionId) return client.getUploadSessionDetail({
+		projectId: input.projectId,
+		sessionId: input.sessionId
+	});
+	return client.listUploadSessions({
+		projectId: input.projectId,
+		commitSha: input.commitSha,
+		branch: input.branch
+	});
+}
+/**
+* Tool metadata
+*/
+const getUploadStatusMetadata = {
+	name: "get_upload_status",
+	title: "Get Upload Status",
+	description: `Check if CI results have been uploaded and processed.
+
+Use this tool to answer "are my test results ready?" after pushing code.
+
+Parameters:
+- projectId (required): The project ID
+- sessionId (optional): Specific upload session ID for detailed status
+- commitSha (optional): Filter by commit SHA to find uploads for a specific commit
+- branch (optional): Filter by branch name
+
+Behavior:
+- If sessionId is provided: returns detailed status with linked test runs and coverage reports
+- Otherwise: returns a list of recent upload sessions (filtered by commitSha/branch if provided)
+
+Processing statuses:
+- "pending" — upload received, processing not started
+- "processing" — files are being parsed
+- "completed" — all files processed successfully, results are ready
+- "error" — some files failed to process
+
+Workflow:
+1. After pushing code, call with commitSha to find the upload session
+2. Check processingStatus — if "completed", results are ready
+3. If "processing" or "pending", wait and check again
+4. Once completed, use the linked testRunIds with get_test_run_details
+
+Returns (list mode):
+- sessions: Array of upload sessions with processing status
+- pagination: Pagination info
+
+Returns (detail mode):
+- session: Upload session details
+- testRuns: Linked test run summaries (id, framework, pass/fail counts)
+- coverageReports: Linked coverage report summaries (id, format)`
 };
-var listProjectsOutputSchema = {
-  projects: z13.array(z13.object({
-    id: z13.string(),
-    name: z13.string(),
-    description: z13.string().nullable().optional(),
-    organization: z13.object({
-      id: z13.string(),
-      name: z13.string(),
-      slug: z13.string()
-    })
-  })),
-  total: z13.number()
+
+//#endregion
+//#region src/tools/list-projects.ts
+/**
+* Input schema for list_projects tool
+*/
+const listProjectsInputSchema = {
+	organizationId: z.string().optional().describe("Filter by organization ID (optional)"),
+	limit: z.number().int().min(1).max(100).optional().describe("Maximum number of projects to return (default: 50)")
 };
+/**
+* Output schema for list_projects tool
+*/
+const listProjectsOutputSchema = {
+	projects: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		description: z.string().nullable().optional(),
+		organization: z.object({
+			id: z.string(),
+			name: z.string(),
+			slug: z.string()
+		})
+	})),
+	total: z.number()
+};
+/**
+* Execute list_projects tool
+*/
 async function executeListProjects(client, input) {
-  const response = await client.listProjects({
-    organizationId: input.organizationId,
-    limit: input.limit
-  });
-  return {
-    projects: response.projects.map((p) => ({
-      id: p.id,
-      name: p.name,
-      description: p.description,
-      organization: p.organization
-    })),
-    total: response.pagination.total
-  };
+	const response = await client.listProjects({
+		organizationId: input.organizationId,
+		limit: input.limit
+	});
+	return {
+		projects: response.projects.map((p) => ({
+			id: p.id,
+			name: p.name,
+			description: p.description,
+			organization: p.organization
+		})),
+		total: response.pagination.total
+	};
 }
-var listProjectsMetadata = {
-  name: "list_projects",
-  title: "List Projects",
-  description: `List all projects you have access to.
+/**
+* Tool metadata
+*/
+const listProjectsMetadata = {
+	name: "list_projects",
+	title: "List Projects",
+	description: `List all projects you have access to.
 
 Returns a list of projects with their IDs, names, and organization info.
 Use this to find project IDs for other tools like get_project_health.
@@ -1347,60 +1702,72 @@ Use this to find project IDs for other tools like get_project_health.
 Requires a user API Key (gaf_). Get one from Account Settings in the Gaffer dashboard.`
 };
 
-// src/tools/list-test-runs.ts
-import { z as z14 } from "zod";
-var listTestRunsInputSchema = {
-  projectId: z14.string().optional().describe("Project ID to list test runs for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
-  commitSha: z14.string().optional().describe("Filter by commit SHA (exact or prefix match)"),
-  branch: z14.string().optional().describe("Filter by branch name"),
-  status: z14.enum(["passed", "failed"]).optional().describe('Filter by status: "passed" (no failures) or "failed" (has failures)'),
-  limit: z14.number().int().min(1).max(100).optional().describe("Maximum number of test runs to return (default: 20)")
+//#endregion
+//#region src/tools/list-test-runs.ts
+/**
+* Input schema for list_test_runs tool
+*/
+const listTestRunsInputSchema = {
+	projectId: z.string().optional().describe("Project ID to list test runs for. Required when using a user API Key (gaf_). Use list_projects to find project IDs."),
+	commitSha: z.string().optional().describe("Filter by commit SHA (exact or prefix match)"),
+	branch: z.string().optional().describe("Filter by branch name"),
+	status: z.enum(["passed", "failed"]).optional().describe("Filter by status: \"passed\" (no failures) or \"failed\" (has failures)"),
+	limit: z.number().int().min(1).max(100).optional().describe("Maximum number of test runs to return (default: 20)")
 };
-var listTestRunsOutputSchema = {
-  testRuns: z14.array(z14.object({
-    id: z14.string(),
-    commitSha: z14.string().optional(),
-    branch: z14.string().optional(),
-    passedCount: z14.number(),
-    failedCount: z14.number(),
-    skippedCount: z14.number(),
-    totalCount: z14.number(),
-    createdAt: z14.string()
-  })),
-  pagination: z14.object({
-    total: z14.number(),
-    hasMore: z14.boolean()
-  })
+/**
+* Output schema for list_test_runs tool
+*/
+const listTestRunsOutputSchema = {
+	testRuns: z.array(z.object({
+		id: z.string(),
+		commitSha: z.string().optional(),
+		branch: z.string().optional(),
+		passedCount: z.number(),
+		failedCount: z.number(),
+		skippedCount: z.number(),
+		totalCount: z.number(),
+		createdAt: z.string()
+	})),
+	pagination: z.object({
+		total: z.number(),
+		hasMore: z.boolean()
+	})
 };
+/**
+* Execute list_test_runs tool
+*/
 async function executeListTestRuns(client, input) {
-  const response = await client.getTestRuns({
-    projectId: input.projectId,
-    commitSha: input.commitSha,
-    branch: input.branch,
-    status: input.status,
-    limit: input.limit || 20
-  });
-  return {
-    testRuns: response.testRuns.map((run) => ({
-      id: run.id,
-      commitSha: run.commitSha || void 0,
-      branch: run.branch || void 0,
-      passedCount: run.summary.passed,
-      failedCount: run.summary.failed,
-      skippedCount: run.summary.skipped,
-      totalCount: run.summary.total,
-      createdAt: run.createdAt
-    })),
-    pagination: {
-      total: response.pagination.total,
-      hasMore: response.pagination.hasMore
-    }
-  };
+	const response = await client.getTestRuns({
+		projectId: input.projectId,
+		commitSha: input.commitSha,
+		branch: input.branch,
+		status: input.status,
+		limit: input.limit || 20
+	});
+	return {
+		testRuns: response.testRuns.map((run) => ({
+			id: run.id,
+			commitSha: run.commitSha || void 0,
+			branch: run.branch || void 0,
+			passedCount: run.summary.passed,
+			failedCount: run.summary.failed,
+			skippedCount: run.summary.skipped,
+			totalCount: run.summary.total,
+			createdAt: run.createdAt
+		})),
+		pagination: {
+			total: response.pagination.total,
+			hasMore: response.pagination.hasMore
+		}
+	};
 }
-var listTestRunsMetadata = {
-  name: "list_test_runs",
-  title: "List Test Runs",
-  description: `List recent test runs for a project with optional filtering.
+/**
+* Tool metadata
+*/
+const listTestRunsMetadata = {
+	name: "list_test_runs",
+	title: "List Test Runs",
+	description: `List recent test runs for a project with optional filtering.
 
 When using a user API Key (gaf_), you must provide a projectId.
 Use list_projects first to find available project IDs.
@@ -1425,53 +1792,86 @@ Use cases:
 - "What's the status of tests on my feature branch?"`
 };
 
-// src/index.ts
+//#endregion
+//#region src/index.ts
+/**
+* Log error to stderr for observability
+* MCP uses stdout for communication, so stderr is safe for logging
+*/
 function logError(toolName, error) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const message = error instanceof Error ? error.message : "Unknown error";
-  const stack = error instanceof Error ? error.stack : void 0;
-  console.error(`[${timestamp}] [gaffer-mcp] ${toolName} failed: ${message}`);
-  if (stack) {
-    console.error(stack);
-  }
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const message = error instanceof Error ? error.message : "Unknown error";
+	const stack = error instanceof Error ? error.stack : void 0;
+	console.error(`[${timestamp}] [gaffer-mcp] ${toolName} failed: ${message}`);
+	if (stack) console.error(stack);
 }
+/**
+* Handle tool error: log it and return MCP error response
+*/
 function handleToolError(toolName, error) {
-  logError(toolName, error);
-  const message = error instanceof Error ? error.message : "Unknown error";
-  return {
-    content: [{ type: "text", text: `Error: ${message}` }],
-    isError: true
-  };
+	logError(toolName, error);
+	return {
+		content: [{
+			type: "text",
+			text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+		}],
+		isError: true
+	};
+}
+/**
+* Register a tool with the MCP server using a consistent pattern.
+* Reduces boilerplate by handling error wrapping and response formatting.
+*/
+function registerTool(server, client, tool) {
+	server.registerTool(tool.metadata.name, {
+		title: tool.metadata.title,
+		description: tool.metadata.description,
+		inputSchema: tool.inputSchema,
+		outputSchema: tool.outputSchema
+	}, async (input) => {
+		try {
+			const output = await tool.execute(client, input);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(output, null, 2)
+				}],
+				structuredContent: output
+			};
+		} catch (error) {
+			return handleToolError(tool.metadata.name, error);
+		}
+	});
 }
+/**
+* Gaffer MCP Server
+*
+* Provides AI assistants with access to test history and health metrics.
+*
+* Supports two authentication modes:
+* 1. User API Keys (gaf_) - Read-only access to all user's projects
+*    Set via GAFFER_API_KEY environment variable
+* 2. Project Upload Tokens (gfr_) - Legacy, single project access
+*/
 async function main() {
-  const apiKey = process.env.GAFFER_API_KEY;
-  if (!apiKey) {
-    console.error("Error: GAFFER_API_KEY environment variable is required");
-    console.error("");
-    console.error("Get your API Key from: https://app.gaffer.sh/account/api-keys");
-    console.error("");
-    console.error("Then configure Claude Code or Cursor with:");
-    console.error(JSON.stringify({
-      mcpServers: {
-        gaffer: {
-          command: "npx",
-          args: ["-y", "@gaffer-sh/mcp"],
-          env: {
-            GAFFER_API_KEY: "gaf_your-api-key-here"
-          }
-        }
-      }
-    }, null, 2));
-    process.exit(1);
-  }
-  const client = GafferApiClient.fromEnv();
-  const server = new McpServer(
-    {
-      name: "gaffer",
-      version: "0.1.0"
-    },
-    {
-      instructions: `Gaffer provides test analytics and coverage data for your projects.
+	if (!process.env.GAFFER_API_KEY) {
+		console.error("Error: GAFFER_API_KEY environment variable is required");
+		console.error("");
+		console.error("Get your API Key from: https://app.gaffer.sh/account/api-keys");
+		console.error("");
+		console.error("Then configure Claude Code or Cursor with:");
+		console.error(JSON.stringify({ mcpServers: { gaffer: {
+			command: "npx",
+			args: ["-y", "@gaffer-sh/mcp"],
+			env: { GAFFER_API_KEY: "gaf_your-api-key-here" }
+		} } }, null, 2));
+		process.exit(1);
+	}
+	const client = GafferApiClient.fromEnv();
+	const server = new McpServer({
+		name: "gaffer",
+		version: "0.1.0"
+	}, { instructions: `Gaffer provides test analytics and coverage data for your projects.
 
 ## Coverage Analysis Best Practices
 
@@ -1489,293 +1889,153 @@ When helping users improve test coverage, combine coverage data with codebase ex
 
 3. **Use path-based queries**: The get_untested_files tool may return many files of a certain type (e.g., UI components). For targeted analysis, use get_coverage_for_file with path prefixes to focus on specific areas of the codebase.
 
-4. **Iterate**: Get baseline \u2192 identify targets \u2192 write tests \u2192 re-check coverage after CI uploads new results.`
-    }
-  );
-  server.registerTool(
-    getProjectHealthMetadata.name,
-    {
-      title: getProjectHealthMetadata.title,
-      description: getProjectHealthMetadata.description,
-      inputSchema: getProjectHealthInputSchema,
-      outputSchema: getProjectHealthOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetProjectHealth(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getProjectHealthMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getTestHistoryMetadata.name,
-    {
-      title: getTestHistoryMetadata.title,
-      description: getTestHistoryMetadata.description,
-      inputSchema: getTestHistoryInputSchema,
-      outputSchema: getTestHistoryOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetTestHistory(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getTestHistoryMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getFlakyTestsMetadata.name,
-    {
-      title: getFlakyTestsMetadata.title,
-      description: getFlakyTestsMetadata.description,
-      inputSchema: getFlakyTestsInputSchema,
-      outputSchema: getFlakyTestsOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetFlakyTests(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getFlakyTestsMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    listTestRunsMetadata.name,
-    {
-      title: listTestRunsMetadata.title,
-      description: listTestRunsMetadata.description,
-      inputSchema: listTestRunsInputSchema,
-      outputSchema: listTestRunsOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeListTestRuns(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(listTestRunsMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    listProjectsMetadata.name,
-    {
-      title: listProjectsMetadata.title,
-      description: listProjectsMetadata.description,
-      inputSchema: listProjectsInputSchema,
-      outputSchema: listProjectsOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeListProjects(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(listProjectsMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getReportMetadata.name,
-    {
-      title: getReportMetadata.title,
-      description: getReportMetadata.description,
-      inputSchema: getReportInputSchema,
-      outputSchema: getReportOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetReport(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getReportMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getSlowestTestsMetadata.name,
-    {
-      title: getSlowestTestsMetadata.title,
-      description: getSlowestTestsMetadata.description,
-      inputSchema: getSlowestTestsInputSchema,
-      outputSchema: getSlowestTestsOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetSlowestTests(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getSlowestTestsMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getTestRunDetailsMetadata.name,
-    {
-      title: getTestRunDetailsMetadata.title,
-      description: getTestRunDetailsMetadata.description,
-      inputSchema: getTestRunDetailsInputSchema,
-      outputSchema: getTestRunDetailsOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetTestRunDetails(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getTestRunDetailsMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    compareTestMetricsMetadata.name,
-    {
-      title: compareTestMetricsMetadata.title,
-      description: compareTestMetricsMetadata.description,
-      inputSchema: compareTestMetricsInputSchema,
-      outputSchema: compareTestMetricsOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeCompareTestMetrics(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(compareTestMetricsMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getCoverageSummaryMetadata.name,
-    {
-      title: getCoverageSummaryMetadata.title,
-      description: getCoverageSummaryMetadata.description,
-      inputSchema: getCoverageSummaryInputSchema,
-      outputSchema: getCoverageSummaryOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetCoverageSummary(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getCoverageSummaryMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getCoverageForFileMetadata.name,
-    {
-      title: getCoverageForFileMetadata.title,
-      description: getCoverageForFileMetadata.description,
-      inputSchema: getCoverageForFileInputSchema,
-      outputSchema: getCoverageForFileOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetCoverageForFile(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getCoverageForFileMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    findUncoveredFailureAreasMetadata.name,
-    {
-      title: findUncoveredFailureAreasMetadata.title,
-      description: findUncoveredFailureAreasMetadata.description,
-      inputSchema: findUncoveredFailureAreasInputSchema,
-      outputSchema: findUncoveredFailureAreasOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeFindUncoveredFailureAreas(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(findUncoveredFailureAreasMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getUntestedFilesMetadata.name,
-    {
-      title: getUntestedFilesMetadata.title,
-      description: getUntestedFilesMetadata.description,
-      inputSchema: getUntestedFilesInputSchema,
-      outputSchema: getUntestedFilesOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetUntestedFiles(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getUntestedFilesMetadata.name, error);
-      }
-    }
-  );
-  server.registerTool(
-    getReportBrowserUrlMetadata.name,
-    {
-      title: getReportBrowserUrlMetadata.title,
-      description: getReportBrowserUrlMetadata.description,
-      inputSchema: getReportBrowserUrlInputSchema,
-      outputSchema: getReportBrowserUrlOutputSchema
-    },
-    async (input) => {
-      try {
-        const output = await executeGetReportBrowserUrl(client, input);
-        return {
-          content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
-          structuredContent: output
-        };
-      } catch (error) {
-        return handleToolError(getReportBrowserUrlMetadata.name, error);
-      }
-    }
-  );
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+4. **Iterate**: Get baseline → identify targets → write tests → re-check coverage after CI uploads new results.
+
+## Finding Invisible Files
+
+Coverage tools can only report on files that were loaded during test execution. Some files have 0% coverage but don't appear in reports at all - these are "invisible" files that were never imported.
+
+To find invisible files:
+1. Use get_coverage_for_file with a path prefix (e.g., "server/") to see what Gaffer tracks
+2. Use the local Glob tool to list all source files in that path
+3. Compare the lists - files in local but NOT in Gaffer are invisible
+4. These files need tests that actually import them
+
+Example: If get_coverage_for_file("server/api") returns user.ts, auth.ts, but Glob finds user.ts, auth.ts, billing.ts - then billing.ts is invisible and needs tests that import it.
+
+## Agentic CI / Test Failure Diagnosis
+
+When helping diagnose CI failures or fix failing tests:
+
+1. **Check flakiness first**: Use get_flaky_tests to identify non-deterministic tests.
+   Skip flaky tests unless the user specifically wants to stabilize them.
+
+2. **Get failure details**: Use get_test_run_details with status='failed'
+   to see error messages and stack traces for failing tests.
+
+3. **Group by root cause**: Use get_failure_clusters to see which failures
+   share the same underlying error — fix the root cause, not individual tests.
+
+4. **Check history**: Use get_test_history to understand if the failure is new
+   (regression) or recurring (existing bug).
+
+5. **Verify fixes**: After code changes, use compare_test_metrics to confirm
+   the specific test now passes.
+
+6. **Prioritize by risk**: Use find_uncovered_failure_areas to identify
+   which failing code has the lowest test coverage — fix those first.
+
+## Checking Upload Status
+
+When an agent needs to know if CI results are ready:
+
+1. Use get_upload_status with commitSha or branch to find upload sessions
+2. Check processingStatus: "completed" means results are ready, "processing" means wait
+3. Once completed, use the linked testRunIds to get test results` });
+	registerTool(server, client, {
+		metadata: getProjectHealthMetadata,
+		inputSchema: getProjectHealthInputSchema,
+		outputSchema: getProjectHealthOutputSchema,
+		execute: executeGetProjectHealth
+	});
+	registerTool(server, client, {
+		metadata: getTestHistoryMetadata,
+		inputSchema: getTestHistoryInputSchema,
+		outputSchema: getTestHistoryOutputSchema,
+		execute: executeGetTestHistory
+	});
+	registerTool(server, client, {
+		metadata: getFlakyTestsMetadata,
+		inputSchema: getFlakyTestsInputSchema,
+		outputSchema: getFlakyTestsOutputSchema,
+		execute: executeGetFlakyTests
+	});
+	registerTool(server, client, {
+		metadata: listTestRunsMetadata,
+		inputSchema: listTestRunsInputSchema,
+		outputSchema: listTestRunsOutputSchema,
+		execute: executeListTestRuns
+	});
+	registerTool(server, client, {
+		metadata: listProjectsMetadata,
+		inputSchema: listProjectsInputSchema,
+		outputSchema: listProjectsOutputSchema,
+		execute: executeListProjects
+	});
+	registerTool(server, client, {
+		metadata: getReportMetadata,
+		inputSchema: getReportInputSchema,
+		outputSchema: getReportOutputSchema,
+		execute: executeGetReport
+	});
+	registerTool(server, client, {
+		metadata: getSlowestTestsMetadata,
+		inputSchema: getSlowestTestsInputSchema,
+		outputSchema: getSlowestTestsOutputSchema,
+		execute: executeGetSlowestTests
+	});
+	registerTool(server, client, {
+		metadata: getTestRunDetailsMetadata,
+		inputSchema: getTestRunDetailsInputSchema,
+		outputSchema: getTestRunDetailsOutputSchema,
+		execute: executeGetTestRunDetails
+	});
+	registerTool(server, client, {
+		metadata: getFailureClustersMetadata,
+		inputSchema: getFailureClustersInputSchema,
+		outputSchema: getFailureClustersOutputSchema,
+		execute: executeGetFailureClusters
+	});
+	registerTool(server, client, {
+		metadata: compareTestMetricsMetadata,
+		inputSchema: compareTestMetricsInputSchema,
+		outputSchema: compareTestMetricsOutputSchema,
+		execute: executeCompareTestMetrics
+	});
+	registerTool(server, client, {
+		metadata: getCoverageSummaryMetadata,
+		inputSchema: getCoverageSummaryInputSchema,
+		outputSchema: getCoverageSummaryOutputSchema,
+		execute: executeGetCoverageSummary
+	});
+	registerTool(server, client, {
+		metadata: getCoverageForFileMetadata,
+		inputSchema: getCoverageForFileInputSchema,
+		outputSchema: getCoverageForFileOutputSchema,
+		execute: executeGetCoverageForFile
+	});
+	registerTool(server, client, {
+		metadata: findUncoveredFailureAreasMetadata,
+		inputSchema: findUncoveredFailureAreasInputSchema,
+		outputSchema: findUncoveredFailureAreasOutputSchema,
+		execute: executeFindUncoveredFailureAreas
+	});
+	registerTool(server, client, {
+		metadata: getUntestedFilesMetadata,
+		inputSchema: getUntestedFilesInputSchema,
+		outputSchema: getUntestedFilesOutputSchema,
+		execute: executeGetUntestedFiles
+	});
+	registerTool(server, client, {
+		metadata: getReportBrowserUrlMetadata,
+		inputSchema: getReportBrowserUrlInputSchema,
+		outputSchema: getReportBrowserUrlOutputSchema,
+		execute: executeGetReportBrowserUrl
+	});
+	registerTool(server, client, {
+		metadata: getUploadStatusMetadata,
+		inputSchema: getUploadStatusInputSchema,
+		outputSchema: getUploadStatusOutputSchema,
+		execute: executeGetUploadStatus
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
 }
 main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
+	console.error("Fatal error:", error);
+	process.exit(1);
 });
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.js.map