@skyramp/mcp 0.3.4 → 0.3.6-rc.1

package/build/services/AnalyticsService.d.ts

@@ -1,5 +1,12 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 export declare class AnalyticsService {
+    /**
+     * Only the fields named here reach the analytics backend. The tool's own
+     * params are NOT forwarded wholesale: they carry the user's prompt, which is
+     * free text about a private codebase and has no business leaving the machine.
+     * Anything added here is sent verbatim -- PushToolEvent on the Go side does no
+     * redaction of its own -- so add a field only when it is safe to publish.
+     */
     static pushTestGenerationToolEvent(toolName: string, result: CallToolResult, params: Record<string, any>): Promise<void>;
     static pushMCPToolEvent(toolName: string, result: CallToolResult | undefined, params: Record<string, any>): Promise<void>;
     /**

package/build/services/AnalyticsService.js

@@ -40,9 +40,15 @@ async function safePushToolEvent(entryPoint, toolName, errorMessage, params) {
     }
 }
 export class AnalyticsService {
+    /**
+     * Only the fields named here reach the analytics backend. The tool's own
+     * params are NOT forwarded wholesale: they carry the user's prompt, which is
+     * free text about a private codebase and has no business leaving the machine.
+     * Anything added here is sent verbatim -- PushToolEvent on the Go side does no
+     * redaction of its own -- so add a field only when it is safe to publish.
+     */
     static async pushTestGenerationToolEvent(toolName, result, params) {
         const analyticsResult = {};
-        analyticsResult["prompt"] = params.prompt;
         analyticsResult["language"] = params.language;
         this.pushMCPToolEvent(toolName, result, analyticsResult);
     }

package/build/services/ModularizationService.js

@@ -28,10 +28,8 @@ The test file \`${params.testFile}\` will remain unchanged. No further action is
         let prompt = "";
         switch (testType) {
             case TestType.UI:
-                prompt = getModularizationPromptForUI(params.testFile);
-                break;
             case TestType.E2E:
-                prompt = getModularizationPromptForUI(params.testFile);
+                prompt = getModularizationPromptForUI(params.testFile, testType, params.language);
                 break;
             case TestType.INTEGRATION:
                 prompt = getModularizationPromptForIntegration(params.testFile);

package/build/services/TestDiscoveryService.d.ts

@@ -45,8 +45,6 @@ export declare class TestDiscoveryService {
     private readonly SUPPORTED_EXTENSIONS;
     private readonly MAX_CONCURRENT_OPERATIONS;
     private readonly MAX_EXTERNAL_FULL_REPO;
-    private readonly TEST_FILE_PATTERNS;
-    private readonly TEST_DIR_PATTERNS;
     /**
      * Discover all tests under testDir — both Skyramp-generated and external (user-written).
      * Uses fast-glob for cross-platform file scanning, then classifies discovered files

package/build/services/TestDiscoveryService.js

@@ -5,6 +5,7 @@ import { TestSource } from "../types/TestAnalysis.js";
 import { TestType } from "../types/TestTypes.js";
 import { buildPathSignatures } from "../utils/pathSignatures.js";
 import fg from "fast-glob";
+import { isDiscoveredTestFile } from "../utils/testFileClassification.js";
 export class TestDiscoveryService {
     EXCLUDED_DIRS = [
         "node_modules",
@@ -34,37 +35,6 @@ export class TestDiscoveryService {
     // In PR mode this hard limit is replaced by relevance-based partitioning which
     // naturally bounds the read set to files relevant to the changed endpoints.
     MAX_EXTERNAL_FULL_REPO = 100;
-    // Test file naming patterns — match against basename.
-    // Includes Skyramp-generated suffixes so that files like orders_smoke.py placed
-    // outside a recognized test directory are still discovered.
-    TEST_FILE_PATTERNS = [
-        /^test_.*\.(py|js|ts|rb|go|php)$/, // test_*.py, test_*.rb, test_*.go
-        /.*_test\.(py|ts|js|go|rs)$/, // *_test.py, *_test.go, *_test.rs
-        /.*\.test\.(ts|js|tsx|jsx)$/, // *.test.ts, *.test.js, *.test.tsx
-        /.*\..*spec\.(ts|js|tsx|jsx|rb)$/, // *.spec.ts, *.e2e-spec.ts, *.unit-spec.ts
-        /.*Test\.(java|kt|kts|cs|scala|swift|m)$/, // *Test.java, *Test.kt, *Test.m (ObjC)
-        /.*Tests\.(cs|swift|m)$/, // *Tests.cs, *Tests.swift, *Tests.m (ObjC)
-        /.*_spec\.rb$/, // *_spec.rb (RSpec)
-        /.*\.test\.php$/, // *.test.php
-        /.*Test\.php$/, // *Test.php (PHPUnit)
-        // Skyramp-generated test suffixes — must be matched even outside test dirs
-        /.*_(?:smoke|contract|fuzz|integration|load|e2e|ui)\.(py|ts|js|java|rb|go|cs|kt|kts|scala|swift|php|rs)$/i,
-    ];
-    // Directory patterns that signal test-owned files — works with both / and \ separators.
-    // Includes standard test dirs, snapshot dirs, and common helper/fixture dirs used by
-    // Playwright, Cypress, and other frameworks for page objects and support code.
-    TEST_DIR_PATTERNS = [
-        /[\\/]tests?[\\/]/,
-        /[\\/]__tests__[\\/]/,
-        /[\\/]__snapshots__[\\/]/, // Jest/Vitest snapshot directories
-        /[\\/]spec[\\/]/,
-        /[\\/]e2e[\\/]/,
-        /[\\/]cypress[\\/]/, // Cypress support, fixtures, plugins
-        /[\\/]playwright[\\/]/, // Playwright fixtures and helpers
-        /[\\/]page-?objects?[\\/]/, // page-objects/, page-object/, pageObjects/
-        /[\\/]fixtures[\\/](?!db[\\/]|seed[\\/]|migrations[\\/])/, // test fixture files (not db/seed/migration fixtures)
-        /[\\/]cypress[\\/]support[\\/]/, // Cypress support directory (scoped to avoid matching app support/ dirs)
-    ];
     /**
      * Discover all tests under testDir — both Skyramp-generated and external (user-written).
      * Uses fast-glob for cross-platform file scanning, then classifies discovered files
@@ -478,12 +448,7 @@ export class TestDiscoveryService {
      * or directory placement.
      */
     isExternalTestFile(filePath) {
-        const basename = path.basename(filePath);
-        if (this.TEST_FILE_PATTERNS.some(p => p.test(basename)))
-            return true;
-        if (this.TEST_DIR_PATTERNS.some(p => p.test(filePath)))
-            return true;
-        return false;
+        return isDiscoveredTestFile(filePath);
     }
     /**
      * Extract metadata from a test file

package/build/services/TestGenerationService.d.ts

@@ -44,6 +44,15 @@ export interface BaseTestParams {
  * empty-string edge (SKYR-3899).
  */
 export declare function deriveEffectiveFramework(language: string | undefined, framework: string | undefined): string;
+/** The files codegen reports it wrote — the block every generation result carries:
+ *
+ *     Successfully generated/updated tests files:
+ *     \t/abs/path/to/orders_integration_test.py
+ *
+ *  Read from the result rather than inferred from the filesystem, so a leftover from an
+ *  earlier attempt or a sibling written by another call is never mistaken for this call's
+ *  output. Empty when the block is absent (nothing to hand off). */
+export declare function generatedFilesFrom(result: string): string[];
 export declare abstract class TestGenerationService {
     protected client: SkyrampClient;
     constructor();
@@ -51,6 +60,13 @@ export declare abstract class TestGenerationService {
     protected validateInputs(params: BaseTestParams): CallToolResult;
     protected abstract buildGenerationOptions(params: BaseTestParams & Record<string, any>): any;
     protected abstract getTestType(): TestType | typeof MOCK_TYPE;
+    /**
+     * Whether this generation's codeReuse hand-off sequences skyramp_modularization
+     * before skyramp_reuse_code (routing: isModularizeFirstTarget). Subclasses that
+     * add their own post-generation steps consult this so modularization is
+     * instructed exactly once.
+     */
+    protected emitsModularizeFirstHandOff(params: BaseTestParams): boolean;
     protected handleApiAnalysis(params: BaseTestParams): Promise<CallToolResult | null>;
     private static readonly STANDARD_HEADERS;
     private static simpleWildcardMatch;

package/build/services/TestGenerationService.js

@@ -3,7 +3,7 @@ import fs from "fs";
 import { SkyrampClient } from "@skyramp/skyramp";
 import { analyzeOpenAPIWithGivenEndpoint } from "../utils/analyze-openapi.js";
 import { isAuthorizationHeaderName, KNOWN_AUTH_HEADERS, resolveAuthFromWorkspace, getWorkspaceSkipTLSVerify, getWorkspaceScopedQueryParams, mergeQueryParamsString, } from "../utils/workspaceAuth.js";
-import { extractPathname, resolveQueryParamsForPath, contributesNothing } from "../workspace/queryParamResolution.js";
+import { extractPathname, resolveQueryParamsForPath, contributesNothing, } from "../workspace/queryParamResolution.js";
 import { getPathParameterValidationError, OUTPUT_DIR_FIELD_NAME, PATH_PARAMS_FIELD_NAME, QUERY_PARAMS_FIELD_NAME, FORM_PARAMS_FIELD_NAME, validateParams, validatePath, validateRequestData, } from "../utils/utils.js";
 import { getEntryPoint } from "../utils/telemetry.js";
 import { getLanguageSteps } from "../utils/language-helper.js";
@@ -12,6 +12,8 @@ import { logger } from "../utils/logger.js";
 import { normalizeLanguageParams } from "../utils/normalizeParams.js";
 import { stageGeneratedPaths, resolveOutputDir } from "../utils/gitStaging.js";
 import { getTestsRepoDir } from "../utils/AnalysisStateManager.js";
+import { recordReuseHandOff } from "../tools/code-refactor/reuse-state.js";
+import { isModularizeFirstTarget } from "../utils/reuseRouting.js";
 /**
  * Derive the framework actually used for generation from the (normalized)
  * language + framework params. A blank/whitespace-only framework is treated as
@@ -35,10 +37,24 @@ export function deriveEffectiveFramework(language, framework) {
  * defaultQueryParams value into that path is not what the design intends
  * (SKYR-4050).
  */
-const SKIP_DEFAULT_QUERY_PARAMS_TEST_TYPES = new Set([
-    TestType.UI,
-    TestType.E2E,
-]);
+const SKIP_DEFAULT_QUERY_PARAMS_TEST_TYPES = new Set([TestType.UI, TestType.E2E]);
+/** The files codegen reports it wrote — the block every generation result carries:
+ *
+ *     Successfully generated/updated tests files:
+ *     \t/abs/path/to/orders_integration_test.py
+ *
+ *  Read from the result rather than inferred from the filesystem, so a leftover from an
+ *  earlier attempt or a sibling written by another call is never mistaken for this call's
+ *  output. Empty when the block is absent (nothing to hand off). */
+export function generatedFilesFrom(result) {
+    const m = /Successfully generated\/updated tests? files?:\s*\n((?:[ \t]+\S[^\n]*\n?)+)/i.exec(result);
+    if (!m)
+        return [];
+    return m[1]
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && path.isAbsolute(l));
+}
 export class TestGenerationService {
     client;
     constructor() {
@@ -74,6 +90,9 @@ export class TestGenerationService {
                 return apiAnalysisResult;
             }
             const result = await this.executeGeneration(generateOptions);
+            // The files this call wrote, as codegen reports them — the reuse hand-off is
+            // recorded per FILE (SKYR-4220).
+            const written = generatedFilesFrom(result);
             const testType = this.getTestType();
             const languageSteps = getLanguageSteps({
                 language: params.language || "",
@@ -83,12 +102,57 @@ export class TestGenerationService {
             // Orchestrate code optimization workflow based on flags
             let postGenerationMessage = "";
             if (params.codeReuse) {
-                // Only code reuse
-                postGenerationMessage += `
+                // Name the framework generation actually used, not the raw parameter:
+                // TS/JS derive to playwright when the caller omitted it, and
+                // skyramp_reuse_code requires framework to route correctly.
+                const effectiveFramework = deriveEffectiveFramework(params.language || "", params.framework);
+                const reuseArgs = `\`testFile\` set to the absolute path of the generated test file, \`language: "${params.language}"\`, \`testType: "${testType}"\`${effectiveFramework ? `, and \`framework: "${effectiveFramework}"\`` : ""}`;
+                // Modularize-first: fresh codegen carries no helper functions (each
+                // endpoint called once, each browser step inline), so modularization is
+                // what creates the named helpers that reuse then consolidates into the
+                // shared utils file. Emitted here, not in the testbot prompt, so the
+                // instruction exists only on runs that actually generated this test type
+                // and needs no hand-maintained step numbering.
+                if (this.emitsModularizeFirstHandOff(params)) {
+                    // SKYR-4220: record the hand-off at the site that emits it, under the same
+                    // condition, so skyramp_execute_test can refuse a test that skipped the pair
+                    // and the report can mark it — without ever owing it for a test that was not
+                    // told to run it. Keyed by the files this call wrote: a test generated into
+                    // the same directory without codeReuse owes nothing.
+                    await recordReuseHandOff(written, testType, params.language || "", effectiveFramework);
+                    // Browser tests: the assertion enhancer anchors new assertions to
+                    // selectors present in the test file, and after modularize → reuse
+                    // those selectors live in the utils file. So for UI the enhancer runs
+                    // FIRST, on the raw file; the extraction rules then keep every value
+                    // assertion in the test body. API enhancers key off response paths,
+                    // so integration keeps its validated modularize → reuse → enhance order.
+                    const enhanceFirst = testType === TestType.UI && !!params.enhanceAssertions;
+                    const steps = [
+                        ...(enhanceFirst
+                            ? [
+                                `Call \`skyramp_enhance_assertions\` with \`testFile\` set to the absolute path of the generated test file, \`testType: "${testType}"\`, and \`enhanceType: "generation"\`, and apply every instruction returned to that file — BEFORE modularization, while the file's selectors are still inline.`,
+                            ]
+                            : []),
+                        `Call \`skyramp_modularization\` with \`testFile\`, \`testType: "${testType}"\`, and \`isTraceBased: true\`, and apply the returned instructions — this extracts the test's steps into named helper functions, which is what makes cross-test reuse possible.`,
+                        `Immediately after writing the modularized file — as your very NEXT skyramp tool call — call \`skyramp_reuse_code\` with ${reuseArgs}. The modularization call does NOT count as this step: reuse is a separate tool and MUST be invoked even when you expect it to find nothing. Follow the returned steps to completion. Sibling tests offering nothing to reuse is a normal outcome — the returned steps still move THIS test's own helpers into the shared utils file and import them back, so the test file IS expected to change; finish those steps, then continue (do NOT retry).`,
+                    ];
+                    const ordering = enhanceFirst
+                        ? "three sub-steps, STRICTLY SEQUENTIAL (never in the same tool-call batch)"
+                        : "two sub-steps, STRICTLY SEQUENTIAL (never in the same tool-call batch), BOTH BEFORE `skyramp_enhance_assertions`";
+                    postGenerationMessage += `
+ Test generated successfully!
+
+⏭️**CRITICAL NEXT STEPS — ${ordering}**:
+${steps.map((text, i) => `${String.fromCharCode(97 + i)}. ${text}`).join("\n")}
+`;
+                }
+                else {
+                    postGenerationMessage += `
  Test generated successfully!
 
-⏭️**CRITICAL NEXT STEP**: Running code reuse analysis with skyramp_reuse_code tool.
+⏭️**CRITICAL NEXT STEP**: Run code reuse analysis by calling the skyramp_reuse_code tool with ${reuseArgs}.
 `;
+                }
             }
             else if (params.modularizeCode) {
                 // Check if test type should be modularized
@@ -210,6 +274,16 @@ The generated test file remains unchanged and ready to use as-is.
             ? { content: [], isError: false }
             : errList;
     }
+    /**
+     * Whether this generation's codeReuse hand-off sequences skyramp_modularization
+     * before skyramp_reuse_code (routing: isModularizeFirstTarget). Subclasses that
+     * add their own post-generation steps consult this so modularization is
+     * instructed exactly once.
+     */
+    emitsModularizeFirstHandOff(params) {
+        return (!!params.codeReuse &&
+            isModularizeFirstTarget(this.getTestType(), params.language));
+    }
     async handleApiAnalysis(params) {
         if (params.apiSchema && params.endpointURL && params.method === "") {
             try {
@@ -274,7 +348,9 @@ The generated test file remains unchanged and ready to use as-is.
     // KNOWN_AUTH_HEADERS is imported from workspaceAuth.ts — single source of truth
     // shared with trace-parser.ts for redaction. See workspaceAuth.ts for the full list.
     static simpleWildcardMatch(pattern, value) {
-        const regex = new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$");
+        const regex = new RegExp("^" +
+            pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") +
+            "$");
         return regex.test(value);
     }
     static traceMatchesFilters(entry, include, exclude) {
@@ -421,7 +497,7 @@ The generated test file remains unchanged and ready to use as-is.
                 // authType handles the Authorization header implicitly — the Go CLI treats
                 // --auth-type and --auth-header as mutually exclusive, so clear authHeader
                 // when it's the standard Authorization header to avoid the conflict.
-                if (isAuthorizationHeaderName(generateOptions.authHeader || '')) {
+                if (isAuthorizationHeaderName(generateOptions.authHeader || "")) {
                     delete generateOptions.authHeader;
                 }
             }

package/build/services/containerEnv.js

@@ -106,23 +106,24 @@ export function buildContainerEnv(options, saveStoragePath, hostEnv = process.en
     // carrying as literals (SKYR-3862). Without this the container never sees
     // them and every generated login fails its guard.
     //
+    // Matched by prefix, like the service URLs above: a multi-credential
+    // `uiCredentials` input exports one keyed pair per credential —
+    // SKYRAMP_UI_USERNAME_<KEY> / SKYRAMP_UI_PASSWORD_<KEY> — alongside the
+    // unkeyed first-credential pair, and codegen binds each generated test to
+    // the pair it was recorded with (SKYR-4110). Dropping a keyed pair here
+    // would fail that test's guard even though the run provided the credential.
+    //
     // Forwarded on presence, not truthiness: the generated guard deliberately
     // distinguishes an unset variable (a misconfiguration, fails fast) from one
     // set to "" (valid on forms that accept a blank password). A truthy check —
     // as used for the URL vars above — would drop the empty case and collapse it
     // into the failure case.
-    //
-    // TODO(SKYR-4110): only ONE credential pair is forwarded, because testbot
-    // exports only the first credential from its `uiCredentials` input. That input
-    // was designed to carry several, so the agent can pick per test case by
-    // authorization role — so a multi-role suite can get a credential its test did
-    // not expect, surfacing as a false 403. The fix is a keyed form
-    // (SKYRAMP_UI_PASSWORD_<KEY>), which needs no new forwarding logic here: the
-    // loop above already forwards SKYRAMP_TEST_SERVICE_URL_* by prefix, so the
-    // same approach applies. Keep the presence-not-truthiness rule when it lands.
-    for (const key of ["SKYRAMP_UI_USERNAME", "SKYRAMP_UI_PASSWORD"]) {
-        const val = hostEnv[key];
-        if (val !== undefined) {
+    for (const [key, val] of Object.entries(hostEnv)) {
+        const isCredential = key === "SKYRAMP_UI_USERNAME" ||
+            key === "SKYRAMP_UI_PASSWORD" ||
+            key.startsWith("SKYRAMP_UI_USERNAME_") ||
+            key.startsWith("SKYRAMP_UI_PASSWORD_");
+        if (isCredential && val !== undefined) {
             env.push(`${key}=${val}`);
         }
     }