@qulib/mcp 0.5.2 → 0.6.0

package/dist/analyze-app-mcp-payload.d.ts

@@ -0,0 +1,12 @@
+import type { AnalyzeResult } from '@qulib/core';
+export interface AnalyzeAppMcpPayloadOptions {
+    includeFullReport?: boolean;
+    /** When true, returns only `toAgentSummary(result)` JSON (QLIB-001). Ignores `includeFullReport`. */
+    agentSummary?: boolean;
+}
+/**
+ * Single place for analyze_app response shaping: default summary-first,
+ * optional full report, or compact agent gate summary.
+ */
+export declare function buildAnalyzeAppMcpPayload(result: AnalyzeResult, input: AnalyzeAppMcpPayloadOptions): unknown;
+//# sourceMappingURL=analyze-app-mcp-payload.d.ts.map

package/dist/analyze-app-mcp-payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-app-mcp-payload.d.ts","sourceRoot":"","sources":["../src/analyze-app-mcp-payload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,MAAM,WAAW,2BAA2B;IAC1C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,qGAAqG;IACrG,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAKT"}

package/dist/analyze-app-mcp-payload.js

@@ -0,0 +1,12 @@
+import { toAgentSummary } from '@qulib/core';
+import { summarizeAnalyzeResult } from './summarize-analyze-result.js';
+/**
+ * Single place for analyze_app response shaping: default summary-first,
+ * optional full report, or compact agent gate summary.
+ */
+export function buildAnalyzeAppMcpPayload(result, input) {
+    if (input.agentSummary === true) {
+        return toAgentSummary(result);
+    }
+    return summarizeAnalyzeResult(result, input.includeFullReport === true);
+}

package/dist/index.js

@@ -16,7 +16,7 @@ const requirePkg = createRequire(import.meta.url);
 const pkg = requirePkg('../package.json');
 import { analyzeApp, detectAuth, exploreAuth, scanRepo, computeAutomationMaturity, } from '@qulib/core';
 import { z } from 'zod';
-import { summarizeAnalyzeResult } from './summarize-analyze-result.js';
+import { buildAnalyzeAppMcpPayload } from './analyze-app-mcp-payload.js';
 import { log } from './logger.js';
 function toolError(code, message, detail) {
     return {
@@ -68,6 +68,10 @@ const AnalyzeInputSchema = z.object({
     timeoutMs: z.number().int().positive().optional(),
     auth: z.discriminatedUnion('type', [FormLoginMcpAuthSchema, StorageStateMcpAuthSchema]).optional(),
     includeFullReport: z.boolean().optional(),
+    agentSummary: z
+        .boolean()
+        .optional()
+        .describe('When true, return only the versioned agent-summary JSON ({ schemaVersion: 1, gate, coverageStatus, topRisks, recommendedNextChecks, honestyNotes, costSummary, deterministicFollowUps }). Use this for CI gates and orchestrators that need a single small payload to decide pass/warn/fail. Overrides includeFullReport.'),
     llmTokenBudget: z.number().int().positive().optional(),
     llmMaxOutputTokensPerCall: z.number().int().positive().optional(),
     testGenerationLimit: z.number().int().positive().max(50).optional(),
@@ -153,7 +157,7 @@ mcpServer.registerTool('detect_auth', {
     }
 });
 mcpServer.registerTool('analyze_app', {
-    description: 'Analyze a deployed web app for quality gaps. Default response is summary-first (top gaps, cost summary, next checks). Set includeFullReport for the full gapAnalysis. Optional llmMaxOutputTokensPerCall / llmTokenBudget (legacy), testGenerationLimit, enableLlmScenarios align with @qulib/core HarnessConfig.',
+    description: 'Analyze a deployed web app for quality gaps. Default response is summary-first (top gaps, cost summary, next checks). Set includeFullReport for the full gapAnalysis. Set agentSummary for the compact gate-decision payload (pass/warn/fail with honesty notes) — use this when calling from a CI gate or orchestrator. Optional llmMaxOutputTokensPerCall / llmTokenBudget (legacy), testGenerationLimit, enableLlmScenarios align with @qulib/core HarnessConfig.',
     inputSchema: AnalyzeInputSchema,
 }, async (input) => {
     try {
@@ -202,7 +206,10 @@ mcpServer.registerTool('analyze_app', {
             progressLog: mcpProgressLog,
             telemetry: telemetrySink,
         });
-        const payload = summarizeAnalyzeResult(result, input.includeFullReport === true);
+        const payload = buildAnalyzeAppMcpPayload(result, {
+            includeFullReport: input.includeFullReport,
+            agentSummary: input.agentSummary,
+        });
         return {
             content: [
                 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qulib/mcp",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "MCP server for Qulib — AI-callable QA gap analysis",
   "license": "MIT",
   "author": "Tapesh Nagarwal",
@@ -29,11 +29,11 @@
   "scripts": {
     "build": "npm --prefix ../.. run build -w @qulib/core && tsc && chmod +x dist/index.js",
     "dev": "tsx src/index.ts",
-    "test": "node --import tsx/esm --test src/__tests__/summarize-analyze-result.test.ts"
+    "test": "node --import tsx/esm --test src/__tests__/summarize-analyze-result.test.ts src/__tests__/analyze-app-mcp-payload.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@qulib/core": "0.5.2",
+    "@qulib/core": "0.6.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {

package/dist/compact-analyze-payload.d.ts

@@ -1,164 +0,0 @@
-import type { AnalyzeResult } from '@qulib/core';
-export declare function buildCompactAnalyzePayload(result: AnalyzeResult, includeFullReport: boolean): AnalyzeResult | {
-    includeFullReport: boolean;
-    note: string;
-    detectedAuth?: {
-        type: "unknown" | "form-login" | "oauth" | "magic-link" | "none";
-        loginUrl: string | null;
-        provider: string | null;
-        hasAuth: boolean;
-        observedSelectors: {
-            usernameSelector: string | null;
-            passwordSelector: string | null;
-            submitSelector: string | null;
-        } | null;
-        oauthButtons: {
-            text: string;
-            provider: string;
-        }[];
-        recommendation: string;
-        authOptions?: {
-            type: "unknown" | "form-login" | "oauth" | "oauth-unknown" | "form-multi" | "magic-link";
-            label: string;
-            id: string;
-            provider: string | null;
-            source: "built-in" | "user-local" | "heuristic";
-            automatable: boolean;
-            confidence: "high" | "medium" | "low";
-            requirements: {
-                method: "storage-state";
-                instruction: string;
-            } | {
-                method: "credentials";
-                fields: {
-                    type: "password" | "text" | "email" | "select" | "checkbox";
-                    name: string;
-                    label: string;
-                    observedOptions: string[];
-                }[];
-            } | {
-                method: "unknown";
-                instruction: string;
-            };
-        }[] | undefined;
-    } | undefined;
-    repoInventorySummary: {
-        framework?: {
-            primary: "unknown" | "nextjs-app-router" | "nextjs-pages-router" | "express" | "remix" | "nuxt" | "sveltekit" | "astro" | "vite";
-            confidence: "high" | "medium" | "low";
-            testFrameworks: ("playwright" | "cypress-e2e" | "cypress-component" | "jest" | "vitest" | "other")[];
-            evidenceCount: number;
-        } | undefined;
-        repoPath: string;
-        scannedAt: string;
-        routeCount: number;
-        testFileCount: number;
-        missingTestIdCount: number;
-        interactiveTsxFilesScanned: number | null;
-        cypressDetected: boolean;
-    } | null;
-    decisionLogPreview: {
-        timestamp: string;
-        reason: string;
-        phase: "observe" | "think" | "act" | "harness";
-        decision: string;
-        metadata?: Record<string, unknown> | undefined;
-    }[];
-    automationMaturitySummary?: {
-        overallScore: number;
-        level: number;
-        label: string;
-        topRecommendations: string[];
-    } | undefined;
-    summary: {
-        status: import("@qulib/core").AnalyzeStatus;
-        coverageScore: number | null;
-        releaseConfidence: number | null;
-        mode: "url-only" | "url-repo" | "auth-required";
-        coveragePagesScanned: number;
-        coverageBudgetExceeded: boolean;
-        coverageWarning: "auth-required" | "budget-exceeded" | "low-coverage" | "navigation-failures" | null;
-        gapCount: number;
-        scenarioCount: number;
-        generatedTestCount: number;
-        publicSurface: {
-            pageCount: number;
-            gapCount: number;
-            accessibilityViolationCount: number;
-            brokenLinkCount: number;
-        } | null;
-    };
-    topGaps: {
-        path: string;
-        category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
-        severity: "critical" | "high" | "medium" | "low";
-        reason: string;
-    }[];
-    costIntelligenceSummary: {
-        maxOutputTokensPerLlmCall: number;
-        usageDataQuality: "none" | "actual" | "estimated" | "mixed";
-        totalInputTokens: number;
-        totalOutputTokens: number;
-        budgetWarningCount: number;
-        maturityLevel: number;
-        maturityLabel: string;
-    } | null;
-    costIntelligence: {
-        maxOutputTokensPerLlmCall: number;
-        budgetRole: "max-output-tokens-per-llm-call";
-        records: {
-            provider: string;
-            model: string;
-            inputTokens: number;
-            outputTokens: number;
-            operationType: "scenario-generation";
-            timestamp: string;
-            dataQuality: "none" | "actual" | "estimated" | "mixed";
-            estimatedCostUsd?: number | undefined;
-            promptHash?: string | undefined;
-            resultHash?: string | undefined;
-            notes?: string | undefined;
-        }[];
-        budgetWarnings: string[];
-        usageSummary: {
-            dataQuality: "none" | "actual" | "estimated" | "mixed";
-            totalInputTokens: number;
-            totalOutputTokens: number;
-        };
-        repeatedOperations: {
-            recommendation: string;
-            promptHash: string;
-            count: number;
-        }[];
-        deterministicMaturity: {
-            label: string;
-            level: number;
-            rationale: string;
-            ceilingNote?: string | undefined;
-        };
-        conversionRecommendations: string[];
-    } | null;
-    nextDeterministicChecks: string[];
-    gapAnalysisPreview: {
-        analyzedAt: string;
-        gapsSample: {
-            path: string;
-            id: string;
-            severity: "critical" | "high" | "medium" | "low";
-            reason: string;
-            category: "untested-route" | "a11y" | "console-error" | "broken-link" | "auth-surface" | "coverage";
-            recommendation?: string | undefined;
-            description?: string | undefined;
-        }[];
-        scenariosOmitted: number;
-        generatedTestsOmitted: number;
-    };
-    routeInventorySummary: {
-        scannedAt: string;
-        baseUrl: string;
-        routeCount: number;
-        pagesSkipped: number;
-        budgetExceeded: boolean;
-    };
-};
-//# sourceMappingURL=compact-analyze-payload.d.ts.map

package/dist/compact-analyze-payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compact-analyze-payload.d.ts","sourceRoot":"","sources":["../src/compact-analyze-payload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAqBjD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,aAAa,EAAE,iBAAiB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAuG+9d,CAAC;sBAA4C,CAAC;sBAA4C,CAAC;iBAAuC,CAAC;;;;;;;;;;;;;;;;;uBAAghB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EAD9sf"}

package/dist/compact-analyze-payload.js

@@ -1,115 +0,0 @@
-const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-function topGapsBySeverity(gaps, limit) {
-    return [...gaps].sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]).slice(0, limit);
-}
-function nextDeterministicChecks(gaps, conversion) {
-    const out = [];
-    const byCat = new Map();
-    for (const g of gaps) {
-        byCat.set(g.category, (byCat.get(g.category) ?? 0) + 1);
-    }
-    for (const [cat, n] of [...byCat.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3)) {
-        out.push(`Add or tighten deterministic coverage for **${cat}** (${n} gap(s) in this scan).`);
-    }
-    out.push(...conversion.slice(0, 2));
-    return out.slice(0, 5);
-}
-export function buildCompactAnalyzePayload(result, includeFullReport) {
-    if (includeFullReport) {
-        return result;
-    }
-    const g = result.gapAnalysis;
-    const ci = g.costIntelligence;
-    const top = topGapsBySeverity(result.gaps, 5);
-    const costSummary = ci
-        ? {
-            maxOutputTokensPerLlmCall: ci.maxOutputTokensPerLlmCall,
-            usageDataQuality: ci.usageSummary.dataQuality,
-            totalInputTokens: ci.usageSummary.totalInputTokens,
-            totalOutputTokens: ci.usageSummary.totalOutputTokens,
-            budgetWarningCount: ci.budgetWarnings.length,
-            maturityLevel: ci.deterministicMaturity.level,
-            maturityLabel: ci.deterministicMaturity.label,
-        }
-        : null;
-    const ps = result.publicSurface;
-    const repo = result.repoInventory;
-    const repoInventorySummary = repo
-        ? {
-            repoPath: repo.repoPath,
-            scannedAt: repo.scannedAt,
-            routeCount: repo.routes.length,
-            testFileCount: repo.testFiles.length,
-            missingTestIdCount: repo.missingTestIds.length,
-            interactiveTsxFilesScanned: repo.interactiveTsxFilesScanned ?? null,
-            cypressDetected: repo.cypressStructure.detected,
-            ...(repo.framework && {
-                framework: {
-                    primary: repo.framework.primary,
-                    confidence: repo.framework.confidence,
-                    testFrameworks: repo.framework.testFrameworks,
-                    evidenceCount: repo.framework.evidence.length,
-                },
-            }),
-        }
-        : null;
-    return {
-        summary: {
-            status: result.status,
-            coverageScore: result.coverageScore,
-            releaseConfidence: g.releaseConfidence,
-            mode: g.mode,
-            coveragePagesScanned: g.coveragePagesScanned,
-            coverageBudgetExceeded: g.coverageBudgetExceeded,
-            coverageWarning: g.coverageWarning ?? null,
-            gapCount: g.gaps.length,
-            scenarioCount: g.scenarios.length,
-            generatedTestCount: g.generatedTests.length,
-            publicSurface: ps === null
-                ? null
-                : {
-                    pageCount: ps.pages.length,
-                    gapCount: ps.gaps.length,
-                    accessibilityViolationCount: ps.accessibilityViolations.length,
-                    brokenLinkCount: ps.brokenLinks.length,
-                },
-        },
-        topGaps: top.map((x) => ({
-            path: x.path,
-            category: x.category,
-            severity: x.severity,
-            reason: x.reason,
-        })),
-        costIntelligenceSummary: costSummary,
-        costIntelligence: ci ?? null,
-        nextDeterministicChecks: ci
-            ? nextDeterministicChecks(result.gaps, ci.conversionRecommendations)
-            : nextDeterministicChecks(result.gaps, []),
-        gapAnalysisPreview: {
-            analyzedAt: g.analyzedAt,
-            gapsSample: g.gaps.slice(0, 8),
-            scenariosOmitted: g.scenarios.length,
-            generatedTestsOmitted: g.generatedTests.length,
-        },
-        routeInventorySummary: {
-            scannedAt: result.routeInventory.scannedAt,
-            baseUrl: result.routeInventory.baseUrl,
-            routeCount: result.routeInventory.routes.length,
-            pagesSkipped: result.routeInventory.pagesSkipped,
-            budgetExceeded: result.routeInventory.budgetExceeded,
-        },
-        ...(repo?.automationMaturity && {
-            automationMaturitySummary: {
-                overallScore: repo.automationMaturity.overallScore,
-                level: repo.automationMaturity.level,
-                label: repo.automationMaturity.label,
-                topRecommendations: repo.automationMaturity.topRecommendations,
-            },
-        }),
-        repoInventorySummary,
-        decisionLogPreview: result.decisionLog.slice(-8),
-        ...(result.detectedAuth !== undefined && { detectedAuth: result.detectedAuth }),
-        includeFullReport: false,
-        note: 'Summary-first payload. Pass includeFullReport: true for the full gapAnalysis (all scenarios, generated tests) and the full repoInventory (test files, missing test IDs).',
-    };
-}