feat: Refactor in-memory storage for Percy results and enhance test file management

Author: tech-sushant

src/lib/inmemory-store.ts

@@ -1,5 +1,4 @@
 export const signedUrlMap = new Map<string, object>();
-export const testFilePathsMap = new Map<string, string[]>();
 
 let _storedPercyResults: any = null;
 
@@ -8,4 +7,7 @@ export const storedPercyResults = {
   set: (value: any) => {
     _storedPercyResults = value;
   },
+  clear: () => {
+    _storedPercyResults = null;
+  },
 };

src/tools/add-percy-snapshots.ts

@@ -1,4 +1,4 @@
-import { testFilePathsMap } from "../lib/inmemory-store.js";
+import { storedPercyResults } from "../lib/inmemory-store.js";
 import { updateFileAndStep } from "./percy-snapshot-utils/utils.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { percyWebSetupInstructions } from "../tools/sdk-utils/percy-web/handler.js";
@@ -8,24 +8,33 @@ export async function updateTestsWithPercyCommands(args: {
   index: number;
 }): Promise<CallToolResult> {
   const { uuid, index } = args;
-  const filePaths = testFilePathsMap.get(uuid);
+  const stored = storedPercyResults.get();
 
-  if (!filePaths) {
+  if (!stored || !stored.uuid || stored.uuid !== uuid || !stored[uuid]) {
     throw new Error(`No test files found in memory for UUID: ${uuid}`);
   }
 
+  const fileStatusMap = stored[uuid];
+  const filePaths = Object.keys(fileStatusMap);
+
   if (index < 0 || index >= filePaths.length) {
     throw new Error(
       `Invalid index: ${index}. There are ${filePaths.length} files for UUID: ${uuid}`,
     );
   }
+
   const result = await updateFileAndStep(
     filePaths[index],
     index,
     filePaths.length,
     percyWebSetupInstructions,
   );
 
+  // Mark this file as updated (true) in the unified structure
+  const updatedStored = { ...stored };
+  updatedStored[uuid][filePaths[index]] = true; // true = updated
+  storedPercyResults.set(updatedStored);
+
   return {
     content: result,
   };

src/tools/list-test-files.ts

@@ -1,5 +1,5 @@
 import { listTestFiles } from "./percy-snapshot-utils/detect-test-files.js";
-import { testFilePathsMap, storedPercyResults } from "../lib/inmemory-store.js";
+import { storedPercyResults } from "../lib/inmemory-store.js";
 import { updateFileAndStep } from "./percy-snapshot-utils/utils.js";
 import { percyWebSetupInstructions } from "./sdk-utils/percy-web/handler.js";
 import crypto from "crypto";
@@ -45,15 +45,31 @@ export async function addListTestFiles(): Promise<CallToolResult> {
   }
 
   if (testFiles.length === 1) {
-    const result = await updateFileAndStep(testFiles[0],0,1,percyWebSetupInstructions);
+    const result = await updateFileAndStep(
+      testFiles[0],
+      0,
+      1,
+      percyWebSetupInstructions,
+    );
     return {
       content: result,
     };
   }
 
   // For multiple files, use the UUID workflow
   const uuid = crypto.randomUUID();
-  testFilePathsMap.set(uuid, testFiles);
+
+  // Store files in the unified structure with initial status false (not updated)
+  const fileStatusMap: { [key: string]: boolean } = {};
+  testFiles.forEach((file) => {
+    fileStatusMap[file] = false; // false = not updated, true = updated
+  });
+
+  // Update storedPercyResults with single UUID for the project
+  const updatedStored = { ...storedResults };
+  updatedStored.uuid = uuid; // Store the UUID reference
+  updatedStored[uuid] = fileStatusMap; // Store files under the UUID key
+  storedPercyResults.set(updatedStored);
 
   return {
     content: [

src/tools/run-percy-scan.ts

@@ -3,6 +3,12 @@ import { PercyIntegrationTypeEnum } from "./sdk-utils/common/types.js";
 import { BrowserStackConfig } from "../lib/types.js";
 import { getBrowserStackAuth } from "../lib/get-auth.js";
 import { fetchPercyToken } from "./sdk-utils/percy-web/fetchPercyToken.js";
+import { storedPercyResults } from "../lib/inmemory-store.js";
+import {
+  getFrameworkTestCommand,
+  PERCY_FALLBACK_STEPS,
+} from "./sdk-utils/percy-web/constants.js";
+import path from "path";
 
 export async function runPercyScan(
   args: {
@@ -18,25 +24,22 @@ export async function runPercyScan(
     type: integrationType,
   });
 
-  const steps: string[] = [generatePercyTokenInstructions(percyToken)];
-
-  if (instruction) {
-    steps.push(
-      `Use the provided test command with Percy:\n${instruction}`,
-      `If this command fails or is incorrect, fall back to the default approach below.`,
-    );
-  }
-
-  steps.push(
-    `Attempt to infer the project's test command from context (high confidence commands first):
-    - Java → mvn test
-    - Python → pytest
-    - Node.js → npm test or yarn test
-    - Cypress → cypress run
-    or from package.json scripts`,
-    `Wrap the inferred command with Percy along with label: \nnpx percy exec --labels=mcp -- <test command>`,
-    `If the test command cannot be inferred confidently, ask the user directly for the correct test command.`,
-  );
+  // Check if we have stored data and project matches
+  const stored = storedPercyResults.get();
+
+  // Compute if we have updated files to run
+  const hasUpdatedFiles = checkForUpdatedFiles(stored, projectName);
+  const updatedFiles = hasUpdatedFiles ? getUpdatedFiles(stored) : [];
+
+  // Build steps array with conditional spread
+  const steps = [
+    generatePercyTokenInstructions(percyToken),
+    ...(hasUpdatedFiles ? generateUpdatedFilesSteps(stored, updatedFiles) : []),
+    ...(instruction && !hasUpdatedFiles
+      ? generateInstructionSteps(instruction)
+      : []),
+    ...(!hasUpdatedFiles ? PERCY_FALLBACK_STEPS : []),
+  ];
 
   const instructionContext = steps
     .map((step, index) => `${index + 1}. ${step}`)
@@ -59,3 +62,57 @@ export PERCY_TOKEN="${percyToken}"
 
 (For Windows: use 'setx PERCY_TOKEN "${percyToken}"' or 'set PERCY_TOKEN=${percyToken}' as appropriate.)`;
 }
+
+const toAbs = (p: string): string | undefined =>
+  p ? path.resolve(p) : undefined;
+
+function checkForUpdatedFiles(
+  stored: any, // storedPercyResults structure
+  projectName: string,
+): boolean {
+  const projectMatches = stored?.projectName === projectName;
+  return (
+    projectMatches &&
+    stored?.uuid &&
+    stored[stored.uuid] &&
+    Object.values(stored[stored.uuid]).some((status) => status === true)
+  );
+}
+
+function getUpdatedFiles(stored: any): string[] {
+  const updatedFiles: string[] = [];
+  const fileStatusMap = stored[stored.uuid!];
+
+  Object.entries(fileStatusMap).forEach(([filePath, status]) => {
+    if (status === true) {
+      updatedFiles.push(filePath);
+    }
+  });
+
+  return updatedFiles;
+}
+
+function generateUpdatedFilesSteps(
+  stored: any,
+  updatedFiles: string[],
+): string[] {
+  const filesToRun = updatedFiles.map(toAbs).filter(Boolean) as string[];
+  const { detectedLanguage, detectedTestingFramework } = stored;
+  const exampleCommand = getFrameworkTestCommand(
+    detectedLanguage,
+    detectedTestingFramework,
+  );
+
+  return [
+    `Run only the updated files with Percy:\n` +
+      `Example: ${exampleCommand} -- <file1> <file2> ...`,
+    `Updated files to run:\n${filesToRun.join("\n")}`,
+  ];
+}
+
+function generateInstructionSteps(instruction: string): string[] {
+  return [
+    `Use the provided test command with Percy:\n${instruction}`,
+    `If this command fails or is incorrect, fall back to the default approach below.`,
+  ];
+}

src/tools/sdk-utils/handler.ts

@@ -45,14 +45,19 @@ export async function setUpPercyHandler(
     const input = SetUpPercySchema.parse(rawInput);
     validatePercyPathandFolders(input);
 
+    // Clear any previous Percy results for a fresh start
+    storedPercyResults.clear();
+
     storedPercyResults.set({
+      projectName: input.projectName,
       detectedLanguage: input.detectedLanguage,
       detectedBrowserAutomationFramework:
         input.detectedBrowserAutomationFramework,
       detectedTestingFramework: input.detectedTestingFramework,
       integrationType: input.integrationType,
       folderPaths: input.folderPaths || [],
       filePaths: input.filePaths || [],
+      uuid: null,
     });
 
     const authorization = getBrowserStackAuth(config);

src/tools/sdk-utils/percy-web/constants.ts

@@ -921,3 +921,51 @@ ${csharpPlaywrightInstructionsSnapshot}
 To run the Percy build, call the tool runPercyScan with the appropriate test command (e.g. npx percy exec -- <command to run the test script file>).
 ${percyReviewSnapshotsStep}
 `;
+
+export function getFrameworkTestCommand(
+  language: string,
+  framework: string,
+): string {
+  const percyPrefix = "npx percy exec --labels=mcp --";
+
+  const nodeCommands: Record<string, string> = {
+    cypress: "cypress run",
+    playwright: "playwright test",
+    webdriverio: "wdio",
+    puppeteer: "node",
+    testcafe: "testcafe",
+    nightwatch: "nightwatch",
+    protractor: "protractor",
+    gatsby: "gatsby build",
+    storybook: "storybook build",
+    ember: "ember test",
+    default: "npm test",
+  };
+
+  const languageMap: Record<string, string> = {
+    python: "python -m pytest",
+    java: "mvn test",
+    ruby: "bundle exec rspec",
+    csharp: "dotnet test",
+  };
+
+  if (language === "nodejs") {
+    const cmd = nodeCommands[framework] ?? nodeCommands.default;
+    return `${percyPrefix} ${cmd}`;
+  }
+
+  const cmd = languageMap[language];
+  return cmd ? `${percyPrefix} ${cmd}` : `${percyPrefix} <test-runner>`;
+}
+
+export const PERCY_FALLBACK_STEPS = [
+  `Attempt to infer the project's test command from context (high confidence commands first):
+- Node.js: npm test, cypress run, npx playwright test, npx wdio, npx testcafe, npx nightwatch, npx protractor, ember test, npx gatsby build, npx storybook build
+- Python: python -m pytest
+- Java: mvn test
+- Ruby: bundle exec rspec
+- C#: dotnet test
+or from package.json scripts`,
+  `Wrap the inferred command with Percy along with label: \nnpx percy exec --labels=mcp -- <test command>`,
+  `If the test command cannot be inferred confidently, ask the user directly for the correct test command.`,
+];