wopee-mcp 1.28.0 → 1.29.1

package/build/tools/index.js

@@ -7,6 +7,7 @@ import { wopeeCreateBlankSuite } from "./wopee_create_blank_suite/index.js";
 import { wopeeFetchAnalysisSuites } from "./wopee_fetch_analysis_suites/index.js";
 import { wopeeFetchExecutedTestCases } from "./wopee_fetch_executed_test_cases/index.js";
 import { wopeeFetchRecentExecutions } from "./wopee_fetch_recent_executions/index.js";
+import { wopeeFetchTestInventory } from "./wopee_fetch_test_inventory/index.js";
 import { wopeeSendChatMessage } from "./wopee_send_chat_message/index.js";
 import { wopeeReadChatHistory } from "./wopee_read_chat_history/index.js";
 import { wopeeCreateGithubIssue } from "./wopee_create_github_issue/index.js";
@@ -17,6 +18,7 @@ export const TOOLS = [
     wopeeFetchAnalysisSuites,
     wopeeFetchExecutedTestCases,
     wopeeFetchRecentExecutions,
+    wopeeFetchTestInventory,
     wopeeFetchVariables,
     wopeeUpdateVariables,
     wopeeDispatchAnalysis,

package/build/tools/shared/artifactContent.js

@@ -0,0 +1,24 @@
+/**
+ * Strip pretty-printing from `tests.json` before it enters the model's context.
+ *
+ * The api commits the USER_STORIES artifact indented so the diff of a test-case
+ * edit is reviewable in a GitHub PR (autonomous-testing/backlog#4252). That
+ * formatting is for humans reading a diff — `fetchArtifact` hands the file
+ * straight to the model, where the extra whitespace is pure token cost and buys
+ * nothing. `fetch_project_summary` pulls this artifact for every suite in a
+ * project, so the cost is multiplied.
+ *
+ * Fails open: content that does not parse is returned untouched. A broken
+ * artifact is still worth showing the model — it can say so.
+ *
+ * Kept free of enum imports so `node --test` (strip-only TS) can cover it; the
+ * artifact-type gate lives in `_compactArtifactContentForModel`.
+ */
+export function compactUserStoriesContent(content) {
+    try {
+        return JSON.stringify(JSON.parse(content));
+    }
+    catch {
+        return content;
+    }
+}

package/build/tools/shared/handlers.js

@@ -2,7 +2,7 @@ import { FetchArtifactInputSchema, UpdateArtifactInputSchema, GenerateAIDataInpu
 import { FetchArtifact, UpdateArtifact } from "./gql-queries.js";
 import { createFetchArtifactInput, createUpdateArtifactInput, createGenerateAIDataInput, } from "./factories.js";
 import { requestClient } from "../../utils/requestClient.js";
-import { _convertToArtifactType, _parseError, _parseGenerateArtifactType, } from "./helpers.js";
+import { _compactArtifactContentForModel, _convertToArtifactType, _parseError, _parseGenerateArtifactType, } from "./helpers.js";
 export async function fetchArtifact(input) {
     try {
         const { type, suiteUuid, identifier } = input;
@@ -28,7 +28,7 @@ export async function fetchArtifact(input) {
             content: [
                 {
                     type: "text",
-                    text: result.fetchArtifact.content,
+                    text: _compactArtifactContentForModel(type, result.fetchArtifact.content),
                 },
             ],
         };

package/build/tools/shared/helpers.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { GenerateAppContext, GenerateGeneralUserStories, GenerateReusableTestCases, GenerateReusableTestCaseSteps, GenerateTestCases, GenerateTestCaseSteps, GenerateUserStoriesWithTestCases, } from "./gql-queries.js";
 import { ArtifactType, GenerateArtifactType } from "./types.js";
 import { RequestError } from "../../utils/requestClient.js";
+import { compactUserStoriesContent } from "./artifactContent.js";
 export function _convertToArtifactType(type) {
     switch (type) {
         case GenerateArtifactType.APP_CONTEXT:
@@ -95,3 +96,13 @@ export function _parseError(error) {
         ],
     };
 }
+/**
+ * Only USER_STORIES is JSON: APP_CONTEXT / GENERAL_USER_STORIES are markdown and
+ * PLAYWRIGHT_CODE is TypeScript, where collapsing whitespace would corrupt the
+ * file. See `compactUserStoriesContent` for why the artifact is compacted at all.
+ */
+export function _compactArtifactContentForModel(type, content) {
+    if (type !== ArtifactType.USER_STORIES)
+        return content;
+    return compactUserStoriesContent(content);
+}

package/build/tools/shared/types.js

@@ -4,6 +4,7 @@ export var ToolName;
     ToolName["WOPEE_FETCH_ANALYSIS_SUITES"] = "wopee_fetch_analysis_suites";
     ToolName["WOPEE_FETCH_EXECUTED_TEST_CASES"] = "wopee_fetch_executed_test_cases";
     ToolName["WOPEE_FETCH_RECENT_EXECUTIONS"] = "wopee_fetch_recent_executions";
+    ToolName["WOPEE_FETCH_TEST_INVENTORY"] = "wopee_fetch_test_inventory";
     ToolName["WOPEE_DISPATCH_ANALYSIS"] = "wopee_dispatch_analysis";
     ToolName["WOPEE_DISPATCH_AGENT"] = "wopee_dispatch_agent";
     ToolName["WOPEE_FETCH_ARTIFACT"] = "wopee_fetch_artifact";

package/build/tools/wopee_fetch_test_inventory/index.js

@@ -0,0 +1,83 @@
+import { getConfig } from "../../utils/getConfig.js";
+import { requestClient } from "../../utils/requestClient.js";
+import { _parseError } from "../shared/helpers.js";
+import { ArtifactType, ToolName, } from "../shared/types.js";
+import { FetchAnalysisSuites, FetchArtifact, FetchExecutedTestCases, } from "../shared/gql-queries.js";
+import { WopeeFetchTestInventoryInputSchema, } from "./schema.js";
+import { buildTestInventory } from "./logic.js";
+export const wopeeFetchTestInventory = {
+    name: ToolName.WOPEE_FETCH_TEST_INVENTORY,
+    config: {
+        title: "Fetch test inventory (counts + statuses)",
+        description: "The authoritative tool for how many tests exist and their latest status. Returns, per analysis, the FULL list of authored test cases joined with their latest execution status — including never-run ones as NOT_RUN. Use this for questions like 'how many tests do I have', 'list the scenarios/test cases in A001', or 'show executed and not-run tests in one table'. Terminology: a 'scenario' is a test case; test cases are grouped under user stories (US001) and identified as US001:TC001. Reusable blocks (user story R001) are counted separately (reusableBlockCount) and are building blocks, not runnable, so they never carry an execution status. Regular tests are all non-R001 test cases. Read-only. Takes an optional analysisIdentifier (e.g. A001) to scope to one analysis; omit to cover every analysis in the project. Prefer this over wopee_fetch_recent_executions / wopee_fetch_executed_test_cases when the user asks about totals or the complete list — those return only test cases that have already run.",
+        inputSchema: WopeeFetchTestInventoryInputSchema.shape,
+    },
+    handler: async (input) => {
+        try {
+            const { WOPEE_PROJECT_UUID } = getConfig();
+            if (!WOPEE_PROJECT_UUID)
+                return {
+                    content: [
+                        { type: "text", text: "WOPEE_PROJECT_UUID is not set" },
+                    ],
+                };
+            const parsed = WopeeFetchTestInventoryInputSchema.parse(input ?? {});
+            const suitesResult = await requestClient(FetchAnalysisSuites, { projectUuid: WOPEE_PROJECT_UUID });
+            let suites = suitesResult?.fetchAnalysisSuites ?? [];
+            if (parsed.analysisIdentifier)
+                suites = suites.filter((s) => s.analysisIdentifier === parsed.analysisIdentifier);
+            if (suites.length === 0)
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: parsed.analysisIdentifier
+                                ? `No analysis found with identifier ${parsed.analysisIdentifier}.`
+                                : "No analyses found in this project yet.",
+                        },
+                    ],
+                };
+            // Fetch the authored test cases (USER_STORIES artifact) and execution
+            // history for every analysis in parallel. A failure on one suite (e.g. an
+            // analysis with no generated tests yet) degrades to an empty result for
+            // that suite rather than failing the whole inventory.
+            const inputs = await Promise.all(suites.map(async (suite) => {
+                const [artifactRes, execRes] = await Promise.allSettled([
+                    requestClient(FetchArtifact, {
+                        input: {
+                            projectUuid: WOPEE_PROJECT_UUID,
+                            suiteUuid: suite.uuid,
+                            type: ArtifactType.USER_STORIES,
+                            ref: suite.analysisIdentifier ?? undefined,
+                        },
+                    }),
+                    requestClient(FetchExecutedTestCases, {
+                        input: {
+                            projectUuid: WOPEE_PROJECT_UUID,
+                            analysisSuiteUuid: suite.uuid,
+                            analysisIdentifier: suite.analysisIdentifier ?? "",
+                        },
+                    }),
+                ]);
+                return {
+                    suite,
+                    artifactContent: artifactRes.status === "fulfilled"
+                        ? (artifactRes.value?.fetchArtifact?.content ?? null)
+                        : null,
+                    execGroups: execRes.status === "fulfilled"
+                        ? (execRes.value?.fetchExecutedTestCases ?? [])
+                        : [],
+                };
+            }));
+            const inventory = buildTestInventory(inputs);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(inventory, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return _parseError(error);
+        }
+    },
+};

package/build/tools/wopee_fetch_test_inventory/logic.js

@@ -0,0 +1,115 @@
+// The special user story that holds reusable blocks (building blocks referenced
+// by other test cases' steps, not independently runnable). Forced onto reusable
+// test cases at generation time (api generateReusableTestCases.ts).
+export const REUSABLE_USER_STORY_ID = "R001";
+export const NOT_RUN = "NOT_RUN";
+/** Parse the USER_STORIES artifact JSON; tolerant of null/empty/malformed. */
+export function parseUserStories(content) {
+    if (!content)
+        return [];
+    try {
+        const parsed = JSON.parse(content);
+        const stories = parsed?.userStories;
+        return Array.isArray(stories) ? stories : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Index every execution by `${userStoryId}::${testCaseId}`, newest first.
+ * Sorted by createdAt descending so index[key][0] is the latest run.
+ */
+export function indexExecutions(groups) {
+    const map = new Map();
+    for (const grp of groups ?? []) {
+        for (const etc of grp.executedTestCases ?? []) {
+            const key = `${etc.userStoryId}::${etc.testCaseId}`;
+            const list = map.get(key);
+            if (list)
+                list.push(etc);
+            else
+                map.set(key, [etc]);
+        }
+    }
+    for (const list of map.values())
+        list.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
+    return map;
+}
+/**
+ * Latest-run verdict, matching CMD rowVerdict precedence: the agent report is
+ * the trace-verified verdict, then the code report, then the raw execution
+ * status, else "not run". Report statuses (PASSED/FAILED/INCOMPLETE) win over
+ * a bare FINISHED — a FINISHED run can still be a FAILED verdict.
+ */
+export function resolveStatus(exec) {
+    if (!exec)
+        return NOT_RUN;
+    const report = exec.agentReportStatus || exec.codeReportStatus;
+    if (report)
+        return report;
+    return exec.executionStatus ?? NOT_RUN;
+}
+function buildAnalysisInventory({ suite, artifactContent, execGroups, }) {
+    const userStories = parseUserStories(artifactContent);
+    const execIndex = indexExecutions(execGroups);
+    const testCases = [];
+    const statusSummary = {};
+    let regularTestCount = 0;
+    let reusableBlockCount = 0;
+    for (const story of userStories) {
+        const isReusable = story.userStoryId === REUSABLE_USER_STORY_ID;
+        for (const tc of story.testCases ?? []) {
+            if (isReusable)
+                reusableBlockCount += 1;
+            else
+                regularTestCount += 1;
+            // Reusable blocks are not independently runnable, so they never carry an
+            // execution status.
+            const exec = isReusable
+                ? undefined
+                : execIndex.get(`${story.userStoryId}::${tc.testCaseId}`)?.[0];
+            const status = resolveStatus(exec);
+            if (!isReusable)
+                statusSummary[status] = (statusSummary[status] ?? 0) + 1;
+            testCases.push({
+                id: `${story.userStoryId}:${tc.testCaseId}`,
+                userStoryId: story.userStoryId,
+                userStoryName: story.userStoryName ?? "",
+                userStoryCategory: story.userStoryCategory ?? "",
+                testCaseId: tc.testCaseId,
+                name: tc.name ?? "",
+                kind: isReusable ? "REUSABLE" : "REGULAR",
+                status,
+                executedAt: exec?.updatedAt ?? exec?.createdAt ?? null,
+            });
+        }
+    }
+    return {
+        analysisIdentifier: suite.analysisIdentifier,
+        suiteUuid: suite.uuid,
+        name: suite.name,
+        suiteRunningStatus: suite.suiteRunningStatus,
+        regularTestCount,
+        reusableBlockCount,
+        statusSummary,
+        testCases,
+    };
+}
+/**
+ * Assemble the full test inventory across analyses: regular vs reusable counts,
+ * and every authored test case with its latest execution status (never-run =
+ * NOT_RUN). This is the single deterministic answer for "how many tests",
+ * "list scenarios", and "executed + not-run in one list".
+ */
+export function buildTestInventory(inputs) {
+    const analyses = inputs.map(buildAnalysisInventory);
+    return {
+        totals: {
+            analyses: analyses.length,
+            regularTests: analyses.reduce((n, a) => n + a.regularTestCount, 0),
+            reusableBlocks: analyses.reduce((n, a) => n + a.reusableBlockCount, 0),
+        },
+        analyses,
+    };
+}

package/build/tools/wopee_fetch_test_inventory/schema.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const WopeeFetchTestInventoryInputSchema = z.object({
+    analysisIdentifier: z
+        .string({
+        description: "Optional analysis identifier (e.g. A001) to scope the inventory to a single analysis. Omit to include every analysis in the project.",
+    })
+        .optional(),
+});

package/package.json

@@ -4,13 +4,14 @@
   "bin": {
     "wopee-mcp": "./build/index.js"
   },
-  "version": "1.28.0",
+  "version": "1.29.1",
   "mcpName": "io.github.Wopee-io/wopee-mcp",
   "description": "Wopee.io MCP server for autonomous testing platform",
   "main": "./build/index.js",
   "scripts": {
     "build": "tsc && chmod 755 build/index.js",
-    "build:clean": "rm -rf build && npm run build"
+    "build:clean": "rm -rf build && npm run build",
+    "test": "node --test \"src/**/*.test.ts\""
   },
   "files": [
     "build",