wopee-mcp 1.27.0 → 1.29.0

package/build/tools/index.js

@@ -7,14 +7,20 @@ 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";
+import { wopeeFetchVariables } from "./wopee_fetch_variables/index.js";
+import { wopeeUpdateVariables } from "./wopee_update_variables/index.js";
 export const TOOLS = [
     wopeeCreateBlankSuite,
     wopeeFetchAnalysisSuites,
     wopeeFetchExecutedTestCases,
     wopeeFetchRecentExecutions,
+    wopeeFetchTestInventory,
+    wopeeFetchVariables,
+    wopeeUpdateVariables,
     wopeeDispatchAnalysis,
     wopeeDispatchAgent,
     wopeeFetchArtifact,

package/build/tools/shared/gql-queries.js

@@ -13,6 +13,26 @@ export const UpdateArtifact = `
     updateArtifact(input: $input)
   }
 `;
+export const FetchProjectVariables = `
+  query FetchProjectVariables($projectUuid: ID!) {
+    fetchProjectVariables(projectUuid: $projectUuid)
+  }
+`;
+export const FetchSuiteVariables = `
+  query FetchSuiteVariables($suiteUuid: ID!) {
+    fetchSuiteVariables(suiteUuid: $suiteUuid)
+  }
+`;
+export const UpdateProjectVariables = `
+  mutation UpdateProjectVariables($input: UpdateProjectVariablesInput!) {
+    updateProjectVariables(input: $input)
+  }
+`;
+export const UpdateSuiteVariables = `
+  mutation UpdateSuiteVariables($suiteUuid: ID!, $additionalVariables: String!) {
+    updateSuiteVariables(suiteUuid: $suiteUuid, additionalVariables: $additionalVariables)
+  }
+`;
 export const DispatchAgent = `
   mutation DispatchAgent(
     $input: TestCasesInput!

package/build/tools/shared/schemas.js

@@ -14,6 +14,18 @@ export const SuiteAnalysisConfigSchema = z.object({
     additionalInstructions: z.string().nullable().default(null),
     additionalVariables: z.string().nullable().default(null),
 });
+// Shared by wopee_dispatch_analysis and wopee_update_variables. Keys must be
+// uppercase (server enforces the same EnvVarKeyRegex on write).
+export const AdditionalVariableSchema = z.object({
+    key: z
+        .string({
+        description: "Variable name. Must be uppercase with underscores only (e.g. MY_VAR, BASE_URL).",
+    })
+        .regex(/^[A-Z_][A-Z0-9_]*$/, "Key must be uppercase alphanumeric with underscores, starting with a letter or underscore"),
+    value: z
+        .string({ description: "Variable value. Must be a non-empty string." })
+        .min(1, "Value must be a non-empty string"),
+});
 export const GenerateAIDataHandlerInputSchema = z.object({
     type: z.nativeEnum(GenerateArtifactType, {
         description: "Type of test artifact to generate. One of: APP_CONTEXT, GENERAL_USER_STORIES, USER_STORIES_WITH_TEST_CASES, TEST_CASES, TEST_CASE_STEPS, REUSABLE_TEST_CASES, REUSABLE_TEST_CASE_STEPS. Start with APP_CONTEXT, then generate stories and test cases from it.",

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";
@@ -12,7 +13,14 @@ export var ToolName;
     ToolName["WOPEE_SEND_CHAT_MESSAGE"] = "wopee_send_chat_message";
     ToolName["WOPEE_READ_CHAT_HISTORY"] = "wopee_read_chat_history";
     ToolName["WOPEE_CREATE_GITHUB_ISSUE"] = "wopee_create_github_issue";
+    ToolName["WOPEE_FETCH_VARIABLES"] = "wopee_fetch_variables";
+    ToolName["WOPEE_UPDATE_VARIABLES"] = "wopee_update_variables";
 })(ToolName || (ToolName = {}));
+export var VariableLevel;
+(function (VariableLevel) {
+    VariableLevel["PROJECT"] = "PROJECT";
+    VariableLevel["ANALYSIS"] = "ANALYSIS";
+})(VariableLevel || (VariableLevel = {}));
 export var GenerateArtifactType;
 (function (GenerateArtifactType) {
     GenerateArtifactType["APP_CONTEXT"] = "APP_CONTEXT";

package/build/tools/wopee_dispatch_analysis/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { SuiteAnalysisConfigSchema } from "../shared/schemas.js";
+import { SuiteAnalysisConfigSchema, AdditionalVariableSchema, } from "../shared/schemas.js";
 var RerunMode;
 (function (RerunMode) {
     RerunMode["FULL"] = "FULL";
@@ -15,16 +15,6 @@ export const DispatchAnalysisInputSchema = z.object({
     suiteAnalysisConfig: SuiteAnalysisConfigSchema,
     rerun: RerunOptionsSchema.nullable().default(null),
 });
-const AdditionalVariableSchema = z.object({
-    key: z
-        .string({
-        description: "Variable name. Must be uppercase with underscores only (e.g. MY_VAR, BASE_URL).",
-    })
-        .regex(/^[A-Z_][A-Z0-9_]*$/, "Key must be uppercase alphanumeric with underscores, starting with a letter or underscore"),
-    value: z
-        .string({ description: "Variable value. Must be a non-empty string." })
-        .min(1, "Value must be a non-empty string"),
-});
 const WopeeRerunOptionsSchema = z.object({
     suiteUuid: z
         .string({

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/build/tools/wopee_fetch_variables/index.js

@@ -0,0 +1,36 @@
+import { getConfig } from "../../utils/getConfig.js";
+import { requestClient } from "../../utils/requestClient.js";
+import { _parseError } from "../shared/helpers.js";
+import { ToolName, VariableLevel } from "../shared/types.js";
+import { FetchProjectVariables, FetchSuiteVariables, } from "../shared/gql-queries.js";
+import { WopeeFetchVariablesInputSchema, } from "./schema.js";
+const textResult = (text) => ({
+    content: [{ type: "text", text }],
+});
+export const wopeeFetchVariables = {
+    name: ToolName.WOPEE_FETCH_VARIABLES,
+    config: {
+        title: "Fetch run-time variables",
+        description: "Read the run-time variables (additionalVariables) that drive analysis/agent runs, at either level. level: PROJECT returns the project-level variables (uses WOPEE_PROJECT_UUID from the environment); level: ANALYSIS returns a specific analysis suite's variables and requires suiteUuid. Read-only. Returns a JSON string array of { key, value, sourceType } entries, or [] when none are set. Use wopee_fetch_analysis_suites to discover suite UUIDs.",
+        inputSchema: WopeeFetchVariablesInputSchema.shape,
+    },
+    handler: async (input) => {
+        try {
+            const { level, suiteUuid } = input;
+            if (level === VariableLevel.ANALYSIS) {
+                if (!suiteUuid)
+                    return textResult("suiteUuid is required when level is ANALYSIS");
+                const result = await requestClient(FetchSuiteVariables, { suiteUuid });
+                return textResult(result?.fetchSuiteVariables ?? "[]");
+            }
+            const { WOPEE_PROJECT_UUID } = getConfig();
+            if (!WOPEE_PROJECT_UUID)
+                return textResult("WOPEE_PROJECT_UUID is not set");
+            const result = await requestClient(FetchProjectVariables, { projectUuid: WOPEE_PROJECT_UUID });
+            return textResult(result?.fetchProjectVariables ?? "[]");
+        }
+        catch (error) {
+            return _parseError(error);
+        }
+    },
+};

package/build/tools/wopee_fetch_variables/schema.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { VariableLevel } from "../shared/types.js";
+export const WopeeFetchVariablesInputSchema = z.object({
+    level: z.nativeEnum(VariableLevel, {
+        description: "Which variable set to read. PROJECT reads the project-level variables (uses WOPEE_PROJECT_UUID from the environment). ANALYSIS reads a specific analysis suite's variables and requires suiteUuid.",
+    }),
+    suiteUuid: z
+        .string({
+        description: "UUID of the analysis suite to read variables from. Required when level is ANALYSIS; ignored when level is PROJECT.",
+    })
+        .nullish(),
+});

package/build/tools/wopee_update_variables/factory.js

@@ -0,0 +1,24 @@
+import { getConfig } from "../../utils/getConfig.js";
+/**
+ * Wire payload for the updateSuiteVariables mutation. The handler guarantees
+ * suiteUuid is present before calling this (ANALYSIS level).
+ */
+export const createUpdateSuiteVariablesInput = (input) => ({
+    suiteUuid: input.suiteUuid,
+    additionalVariables: JSON.stringify(input.variables),
+});
+/**
+ * Wire payload for the updateProjectVariables mutation, injecting
+ * WOPEE_PROJECT_UUID from the environment (PROJECT level).
+ */
+export const createUpdateProjectVariablesInput = (input) => {
+    const { WOPEE_PROJECT_UUID } = getConfig();
+    if (!WOPEE_PROJECT_UUID)
+        throw new Error("WOPEE_PROJECT_UUID is not set");
+    return {
+        input: {
+            projectUuid: WOPEE_PROJECT_UUID,
+            additionalVariables: JSON.stringify(input.variables),
+        },
+    };
+};

package/build/tools/wopee_update_variables/index.js

@@ -0,0 +1,38 @@
+import { requestClient } from "../../utils/requestClient.js";
+import { withRetry } from "../../utils/withRetry.js";
+import { _parseError } from "../shared/helpers.js";
+import { ToolName, VariableLevel } from "../shared/types.js";
+import { UpdateProjectVariables, UpdateSuiteVariables, } from "../shared/gql-queries.js";
+import { createUpdateProjectVariablesInput, createUpdateSuiteVariablesInput, } from "./factory.js";
+import { WopeeUpdateVariablesInputSchema, } from "./schema.js";
+const textResult = (text) => ({
+    content: [{ type: "text", text }],
+});
+export const wopeeUpdateVariables = {
+    name: ToolName.WOPEE_UPDATE_VARIABLES,
+    config: {
+        title: "Update run-time variables",
+        description: "Upsert the run-time variables (additionalVariables) that drive analysis/agent runs, at either level. level: PROJECT writes the project-level variables (uses WOPEE_PROJECT_UUID from the environment); level: ANALYSIS writes a specific analysis suite's variables and requires suiteUuid. Merge semantics: keys in variables[] are added or overwritten, existing keys not listed are preserved. Keys must be uppercase (e.g. BASE_URL); the server re-sanitizes and drops invalid keys. Returns a confirmation on success.",
+        inputSchema: WopeeUpdateVariablesInputSchema.shape,
+    },
+    handler: async (input) => {
+        try {
+            const { level, suiteUuid } = input;
+            if (level === VariableLevel.ANALYSIS) {
+                if (!suiteUuid)
+                    return textResult("suiteUuid is required when level is ANALYSIS");
+                const result = await withRetry(() => requestClient(UpdateSuiteVariables, createUpdateSuiteVariablesInput(input)));
+                if (!result?.updateSuiteVariables)
+                    return textResult("Failed to update suite variables");
+                return textResult("Suite variables updated successfully");
+            }
+            const result = await withRetry(() => requestClient(UpdateProjectVariables, createUpdateProjectVariablesInput(input)));
+            if (!result?.updateProjectVariables)
+                return textResult("Failed to update project variables");
+            return textResult("Project variables updated successfully");
+        }
+        catch (error) {
+            return _parseError(error);
+        }
+    },
+};

package/build/tools/wopee_update_variables/schema.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { VariableLevel } from "../shared/types.js";
+import { AdditionalVariableSchema } from "../shared/schemas.js";
+export const WopeeUpdateVariablesInputSchema = z.object({
+    level: z.nativeEnum(VariableLevel, {
+        description: "Which variable set to write. PROJECT writes the project-level variables (uses WOPEE_PROJECT_UUID from the environment). ANALYSIS writes a specific analysis suite's variables and requires suiteUuid.",
+    }),
+    suiteUuid: z
+        .string({
+        description: "UUID of the analysis suite to write variables to. Required when level is ANALYSIS; ignored when level is PROJECT.",
+    })
+        .nullish(),
+    variables: z.array(AdditionalVariableSchema, {
+        description: "Variables to upsert. Each needs an uppercase key (e.g. BASE_URL) and a non-empty value. Merge semantics: keys listed here are added or overwritten; existing keys not listed here are preserved.",
+    }),
+});

package/package.json

@@ -4,13 +4,14 @@
   "bin": {
     "wopee-mcp": "./build/index.js"
   },
-  "version": "1.27.0",
+  "version": "1.29.0",
   "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",