@qulib/mcp 0.6.0 → 0.8.2

package/dist/index.js

@@ -14,7 +14,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 const requirePkg = createRequire(import.meta.url);
 const pkg = requirePkg('../package.json');
-import { analyzeApp, detectAuth, exploreAuth, scanRepo, computeAutomationMaturity, } from '@qulib/core';
+import { analyzeApp, detectAuth, exploreAuth, scanRepo, computeAutomationMaturity, scaffoldTests, discoverApiSurfaceWithRepo, computeApiCoverage, } from '@qulib/core';
 import { z } from 'zod';
 import { buildAnalyzeAppMcpPayload } from './analyze-app-mcp-payload.js';
 import { log } from './logger.js';
@@ -261,5 +261,103 @@ mcpServer.registerTool('qulib_score_automation', {
         return toolError('QULIB_REPO_SCORE_FAILED', msg, err instanceof Error ? err.stack : undefined);
     }
 });
+const ScaffoldTestsInputSchema = z.object({
+    url: z.string().url().describe('URL of the deployed web app to scaffold tests for'),
+    framework: z
+        .enum(['cypress-e2e', 'playwright'])
+        .optional()
+        .describe('Test framework to generate. Default: cypress-e2e'),
+    maxPagesToScan: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .optional()
+        .describe('Max pages to crawl when running analyze_app internally. Default: 10'),
+});
+mcpServer.registerTool('qulib_scaffold_tests', {
+    description: 'Generate a ready-to-run test scaffold for a deployed web app. Crawls the URL, identifies quality gaps and user flows, then produces framework-specific test files (Cypress or Playwright) plus the project config (cypress.config.ts or playwright.config.ts) and package.json deps. Returns generatedTests (array of {filename, code, outputPath}) and projectConfig so an agent can write the files directly to a repo without any manual test-writing.',
+    inputSchema: ScaffoldTestsInputSchema,
+}, async ({ url, framework, maxPagesToScan }) => {
+    try {
+        log.info(`qulib_scaffold_tests url=${url} framework=${framework ?? 'cypress-e2e'} maxPagesToScan=${maxPagesToScan ?? 10}`);
+        const result = await scaffoldTests(url, {
+            framework: framework ?? 'cypress-e2e',
+            maxPagesToScan: maxPagesToScan ?? 10,
+            progressLog: mcpProgressLog,
+            telemetry: telemetrySink,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        url: result.url,
+                        framework: result.framework,
+                        scenarioCount: result.scenarios.length,
+                        testCount: result.generatedTests.length,
+                        generatedTests: result.generatedTests,
+                        projectConfig: result.projectConfig,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`qulib_scaffold_tests failed: ${msg}`);
+        return toolError('QULIB_SCAFFOLD_FAILED', msg, err instanceof Error ? err.stack : undefined);
+    }
+});
+const ScoreApiInputSchema = z.object({
+    repoPath: z.string().describe('Absolute path to the repository on the MCP host filesystem'),
+    enableTier3: z
+        .boolean()
+        .optional()
+        .describe('Enable Tier3 heuristic discovery (currently: tRPC router definitions). Default false. Tier1=OpenAPI specs, Tier2=framework routes (Next.js, Express, Fastify, NestJS), Tier3=heuristic.'),
+    includeEndpointDetail: z
+        .boolean()
+        .optional()
+        .describe('When true, includes per-endpoint coverage detail in the response. Default false.'),
+});
+mcpServer.registerTool('qulib_score_api', {
+    description: 'Discover API endpoints in a repository and score their test coverage. Returns an api-test-coverage dimension score (0–100) with per-endpoint contextual evidence — which endpoints are covered by tests and which are not. Discovery is evidence-only: Tier1=OpenAPI/Swagger specs, Tier2=framework routes (Next.js App-Router route.ts exports, Pages API routes, Express, Fastify, Hono, NestJS decorators), Tier3=heuristic opt-in (tRPC). Never fabricates endpoints. Returns "not_applicable" when no API endpoints are found.',
+    inputSchema: ScoreApiInputSchema,
+}, async ({ repoPath, enableTier3, includeEndpointDetail }) => {
+    try {
+        const abs = validateAbsoluteRepoPath(repoPath);
+        log.info(`qulib_score_api repoPath=${abs} enableTier3=${enableTier3 ?? false}`);
+        const repo = await scanRepo(abs);
+        const apiSurfaceResult = await discoverApiSurfaceWithRepo(abs, repo, {
+            enableTier3: enableTier3 ?? false,
+        });
+        const coverageResult = computeApiCoverage(repo, apiSurfaceResult);
+        const payload = {
+            repoPath: abs,
+            computedAt: new Date().toISOString(),
+            endpointsDiscovered: apiSurfaceResult.endpoints.length,
+            openApiSpecsFound: apiSurfaceResult.openApiSpecsFound,
+            tier3Enabled: apiSurfaceResult.tier3Enabled,
+            dimension: coverageResult.dimension,
+            untestedHighSeverityCount: coverageResult.untestedHighSeverityCount,
+            untestedMediumSeverityCount: coverageResult.untestedMediumSeverityCount,
+        };
+        if (includeEndpointDetail === true) {
+            payload['endpointCoverage'] = coverageResult.endpointCoverage;
+        }
+        log.info(`qulib_score_api done endpoints=${apiSurfaceResult.endpoints.length} score=${coverageResult.dimension.score} applicability=${coverageResult.dimension.applicability ?? 'applicable'}`);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('repoPath must')) {
+            return toolError('QULIB_INPUT_INVALID', msg, undefined);
+        }
+        log.error(`qulib_score_api failed: ${msg}`);
+        return toolError('QULIB_API_SCORE_FAILED', msg, err instanceof Error ? err.stack : undefined);
+    }
+});
 const transport = new StdioServerTransport();
 await mcpServer.connect(transport);

package/dist/summarize-analyze-result.d.ts

@@ -71,7 +71,7 @@ export declare function summarizeAnalyzeResult(result: AnalyzeResult, includeFul
         topRecommendations: string[];
         dimensions: {
             guidance?: string | undefined;
-            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio";
+            dimension: "test-coverage-breadth" | "framework-adoption" | "test-id-hygiene" | "ci-integration" | "auth-test-coverage" | "component-test-ratio" | "api-test-coverage";
             score: number;
             applicability: "unknown" | "applicable" | "not_applicable";
         }[];
@@ -96,7 +96,7 @@ export declare function summarizeAnalyzeResult(result: AnalyzeResult, includeFul
     };
     topGaps: {
         path: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
         severity: "critical" | "high" | "medium" | "low";
         reason: string;
     }[];
@@ -152,7 +152,7 @@ export declare function summarizeAnalyzeResult(result: AnalyzeResult, includeFul
             id: string;
             severity: "critical" | "high" | "medium" | "low";
             reason: string;
-            category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
+            category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage" | "untested-api-endpoint";
             recommendation?: string | undefined;
             description?: string | undefined;
         }[];

package/dist/summarize-analyze-result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"summarize-analyze-result.d.ts","sourceRoot":"","sources":["../src/summarize-analyze-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAqBjD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA6G0td,CAAC;sBAA4C,CAAC;sBAA4C,CAAC;iBAAuC,CAAC;;;;;;;;;;;;;;;;;uBAAghB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EADr8e"}
+{"version":3,"file":"summarize-analyze-result.d.ts","sourceRoot":"","sources":["../src/summarize-analyze-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAqBjD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA6G84d,CAAC;sBAA4C,CAAC;sBAA4C,CAAC;iBAAuC,CAAC;;;;;;;;;;;;;;;;;uBAAghB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EADznf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qulib/mcp",
-  "version": "0.6.0",
+  "version": "0.8.2",
   "description": "MCP server for Qulib — AI-callable QA gap analysis",
   "license": "MIT",
   "author": "Tapesh Nagarwal",
@@ -33,7 +33,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@qulib/core": "0.6.0",
+    "@qulib/core": "0.8.2",
     "zod": "^3.23.0"
   },
   "devDependencies": {