@gaffer-sh/mcp 0.4.1 → 0.4.2

package/README.md

@@ -20,9 +20,17 @@ This MCP server connects AI coding assistants like Claude Code and Cursor to you
 
 ## Setup
 
-### Claude Code
+### Claude Code (CLI)
 
-Add to your Claude Code settings (`~/.claude.json` or project `.claude/settings.json`):
+The easiest way to add the Gaffer MCP server is via the Claude Code CLI:
+
+```bash
+claude mcp add gaffer -e GAFFER_API_KEY=gaf_your_api_key_here -- npx -y @gaffer-sh/mcp
+```
+
+### Claude Code (Manual)
+
+Alternatively, add to your Claude Code settings (`~/.claude.json` or project `.claude/settings.json`):
 
 ```json
 {

package/dist/index.js

@@ -1443,6 +1443,28 @@ function handleToolError(toolName, error) {
     isError: true
   };
 }
+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);
+      }
+    }
+  );
+}
 async function main() {
   const apiKey = process.env.GAFFER_API_KEY;
   if (!apiKey) {
@@ -1489,289 +1511,105 @@ 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);
-      }
+4. **Iterate**: Get baseline \u2192 identify targets \u2192 write tests \u2192 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.`
     }
   );
+  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: 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
+  });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gaffer-sh/mcp",
   "type": "module",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "MCP server for Gaffer test history - give your AI assistant memory of your tests",
   "license": "MIT",
   "author": "Gaffer <hello@gaffer.sh>",