@skyramp/mcp 0.4.1 → 0.4.2-rc.2

package/build/utils/pom-scope/strip.js

@@ -1,3 +1,195 @@
+/**
+ * Whether a `/` at `i` opens a regex literal rather than a division.
+ *
+ * The standard heuristic: a regex may only start where a VALUE may start, so the last
+ * significant character before it decides. `a / b` is division; `= /x/`, `( /x/`,
+ * `return /x/` are regex literals. A regex is not an edge case for these scanners —
+ * `/https:\/\//` holds `//`, and a lexer that does not know the literal reads that as
+ * the start of a comment and blanks the rest of the line.
+ */
+/** Whether position `k` falls inside a span the lexer already classified — a string, a
+ *  comment or a regex. Every span before the current position is complete, so this is
+ *  the state every backward look must consult. A quoted `)`, a `*\/` and a comment
+ *  between a keyword and its value each defeated one of the three looks below. */
+/** Every keyword a value may follow, so a `/` after one opens a regex and a `{` after
+ *  one opens an object literal. `throw /[/*]/` is the form that reads naturally in a
+ *  test file; without it the `/*` inside the character class opened a block comment
+ *  and blanked the rest of the file. */
+const VALUE_KEYWORDS = [
+    "return",
+    "throw",
+    "typeof",
+    "void",
+    "delete",
+    "instanceof",
+    "new",
+    "case",
+    "default",
+    "in",
+    "of",
+    "do",
+    "else",
+    "yield",
+    "await",
+];
+/** A `{` after one of these opens a BLOCK, never an object literal. They are in the
+ *  list above because a `/` after them opens a regex — `else /re/.test(v)` is valid —
+ *  and one list answering both questions read `else {}` as a value. */
+const BLOCK_KEYWORDS = ["else", "do"];
+/** The keyword token ending at `j`, or "" when the word there is not one.
+ *
+ *  A word after a `.` — or a `?.` — is a PROPERTY NAME, not a keyword: `obj.return`
+ *  and `it.return()` are ordinary member accesses, and reading them as the keyword
+ *  opened a regex at the division that follows, which then swallowed the first slash
+ *  of a trailing comment. Asked once, so the two keyword lookups below cannot drift.
+ */
+function keywordAt(src, j, done) {
+    const word = (src.slice(0, j + 1).match(/[A-Za-z_$][\w$]*$/) ?? [""])[0];
+    if (!word)
+        return "";
+    let k = j - word.length;
+    while (k >= 0 && (/\s/.test(src[k]) || triviaAt(done, k)))
+        k--;
+    return k >= 0 && src[k] === "." ? "" : word;
+}
+function spanAt(done, k) {
+    return done.find((s) => k >= s.start && k < s.end);
+}
+/** A comment is TRIVIA: the token before a `/` is whatever precedes the comment. A
+ *  string or a regex is a VALUE, so a `/` after one is a division — `"4" / 2` and
+ *  `/re/ / 2` both divide. Skipping every classified span read `= "4" /` as a regex
+ *  opener and swallowed the comment that followed. */
+function triviaAt(done, k) {
+    return spanAt(done, k)?.kind === "comment";
+}
+/** Structure only. A parenthesis inside a string, a comment or a regex is not part of
+ *  the balance: a quoted `)` in `if (check(")"))` hid the `if`. */
+function inertAt(done, k) {
+    return spanAt(done, k) !== undefined;
+}
+/** Whether the `)` at `close` ends the head of a control statement rather than a
+ *  call or a grouping. Matched back to its opening paren, then judged by the keyword
+ *  before it. */
+function closesControlHead(src, close, done) {
+    // Parentheses inside a string, a comment or a regex are not structure. They are
+    // already classified, because every span before this point is complete — a quoted
+    // `)` in `if (check(")"))` hid the `if` when the count read raw characters.
+    const inert = (k) => inertAt(done, k);
+    let depth = 0;
+    let k = close;
+    for (; k >= 0; k--) {
+        if (inert(k))
+            continue;
+        if (src[k] === ")")
+            depth++;
+        else if (src[k] === "(") {
+            depth--;
+            if (depth === 0)
+                break;
+        }
+    }
+    if (k < 0)
+        return false;
+    // A comment sits between the keyword and its head as legally as whitespace does:
+    // `if /* note */ (ready)`. Both are skipped, or the `*\/` reads as the keyword.
+    let j = k - 1;
+    while (j >= 0 && (/\s/.test(src[j]) || triviaAt(done, j)))
+        j--;
+    // Through the same question: `obj.if(ready)` is a call on a property, not a head.
+    const word = keywordAt(src, j, done);
+    return ["if", "while", "for", "with", "switch", "catch"].includes(word);
+}
+/** Whether the `}` at `close` ends an object literal rather than a block. Matched back
+ *  to its `{`, then judged by whether a VALUE could have started there. */
+function closesObjectLiteral(src, close, done) {
+    let depth = 0;
+    let k = close;
+    for (; k >= 0; k--) {
+        if (inertAt(done, k))
+            continue;
+        if (src[k] === "}")
+            depth++;
+        else if (src[k] === "{") {
+            depth--;
+            if (depth === 0)
+                break;
+        }
+    }
+    if (k < 0)
+        return false;
+    let j = k - 1;
+    while (j >= 0 && (/\s/.test(src[j]) || triviaAt(done, j)))
+        j--;
+    if (j < 0)
+        return false;
+    // `:` is DELIBERATELY absent, though `{ a: {} }` is an object literal. This
+    // function decides one thing — whether a `/` after the closing `}` divides — and
+    // the two wrong answers do not cost the same. Reading a regex where a division
+    // stands is bounded: a regex literal cannot cross a line, and an unterminated one
+    // is rejected. Reading a division where a regex stands lets a `/*` inside that
+    // regex open a block comment that runs to the end of the file. A colon introduces
+    // a statement label, a `case` clause and a `default` clause — all blocks, all of
+    // which a `/` may follow — so the safe answer is also the common one here. A
+    // division straight after a nested object literal is what it costs.
+    if ("=(,[!&|?+-*%~^<>".includes(src[j]))
+        return true;
+    // A keyword can introduce the value too: `return {}`, `yield {}`, `typeof {}`.
+    // Judging the matching `{` by the preceding CHARACTER alone missed every one of
+    // them, so `return {} / 2` read as a block and the slash opened a regex.
+    const word = keywordAt(src, j, done);
+    if (BLOCK_KEYWORDS.includes(word))
+        return false;
+    return VALUE_KEYWORDS.includes(word);
+}
+function opensRegex(src, i, done) {
+    let j = i - 1;
+    while (j >= 0 && (/\s/.test(src[j]) || triviaAt(done, j)))
+        j--;
+    if (j < 0)
+        return true;
+    // A string or a regex ENDS here, so the slash divides its value.
+    if (spanAt(done, j)?.kind === "string")
+        return false;
+    const prev = src[j];
+    // `++` and `--` are POSTFIX here: `count++ / 2` is a division. Reading the `/` as a
+    // regex opener swallowed the rest of the line, so the line comment after it was
+    // never recognised — and a gate marker in that comment shipped unstripped.
+    if ((prev === "+" || prev === "-") && src[j - 1] === prev)
+        return false;
+    // JSX closes a tag with a slash, and a page object in a React repository is a `.tsx`
+    // file, so this is ordinary input. Both closing forms put the slash exactly where a
+    // value may start, so the heuristic opened a regex, terminated it on the first slash
+    // of the following comment, and left that comment unclassified — a marker in it
+    // shipped, and its text stayed readable to every scanner built on this file.
+    //
+    // ADJACENCY is what separates the two readings, so neither rule costs a real literal:
+    // JSX writes `</`, while a regex after a comparison is written `a < /re/`. `/>` is
+    // only re-read where the preceding `}` closes a JSX expression container — after `(`
+    // or `=` it stays the literal it is, so `s.split(/>/)` is untouched.
+    // Only a TAG NAME can follow the `</` of a closing tag — a letter, `_`, `$`, or the
+    // `>` of a fragment. A character that cannot start one means this is a regex written
+    // tight against a comparison: `a</[/*]/.test(v)` is valid, if unusual, JavaScript.
+    if (prev === "<" && j === i - 1 && /[A-Za-z_$>]/.test(src[i + 1] ?? ""))
+        return false;
+    if (prev === "}" && src[i + 1] === ">")
+        return false;
+    // A `}` closes a BLOCK, after which a statement — and so a regex — may start; or it
+    // closes an OBJECT LITERAL, which is a value, after which `/` divides. Decided by
+    // what precedes the matching `{`, the same way the control head is.
+    if (prev === "}")
+        return !closesObjectLiteral(src, j, done);
+    if ("=(,:[!&|?{;+-*%~^<>".includes(prev))
+        return true;
+    // A `)` usually ends a call, and `total(a) / 2` is a division. But the `)` that
+    // closes an `if (…)` head is followed by a STATEMENT, so a `/` after it opens a
+    // regex: `if (ready) /re/.test(v)`. Reading that as division let the `/*` inside a
+    // character class open a block comment and hide every later comment.
+    if (prev === ")" && closesControlHead(src, j, done))
+        return true;
+    // A keyword that takes a value next. `)` and an identifier character mean division.
+    const word = /[A-Za-z_$]/.test(prev) ? keywordAt(src, j, done) : "";
+    return VALUE_KEYWORDS.includes(word);
+}
 /**
  * Single lexer-lite pass over the source classifying every line comment, block comment, and
  * string/template literal span (escaped quotes handled; a template literal's `${...}`
@@ -27,6 +219,43 @@ function classifySpans(src) {
             spans.push({ kind: "comment", start, end: i });
             continue;
         }
+        // Classified as a string: the callers that blank strings want a regex's contents
+        // inert for the same reason, and the ones that blank comments must not touch it.
+        if (c === "/" && opensRegex(src, i, spans)) {
+            const start = i;
+            i++;
+            let inClass = false;
+            let closed = false;
+            while (i < n) {
+                const ch = src[i];
+                if (ch === "\\") {
+                    i += 2;
+                    continue;
+                }
+                // A regex literal cannot span a line. An unterminated one is not a literal.
+                if (ch === "\n")
+                    break;
+                if (ch === "[")
+                    inClass = true;
+                else if (ch === "]")
+                    inClass = false;
+                else if (ch === "/" && !inClass) {
+                    i++;
+                    closed = true;
+                    break;
+                }
+                i++;
+            }
+            if (!closed) {
+                i = start + 1;
+                continue;
+            }
+            // Trailing flags belong to the literal.
+            while (i < n && /[a-z]/.test(src[i]))
+                i++;
+            spans.push({ kind: "string", start, end: i });
+            continue;
+        }
         if (c === "'" || c === '"' || c === "`") {
             const quote = c;
             const start = i;
@@ -72,6 +301,15 @@ function blankSpans(src, spans) {
     }
     return out.join("");
 }
+/** Every line- and block-comment span in `src`, in source order. Exported for callers
+ * that must decide whether a `//` OPENS a comment rather than sits inside one: a `//`
+ * on its own line inside `/* … *\/` opens nothing, and deleting that line can take the
+ * block's terminator with it. */
+export function commentSpans(src) {
+    return classifySpans(src)
+        .filter((s) => s.kind === "comment")
+        .map(({ start, end }) => ({ start, end }));
+}
 /** Blanks line/block comments only, preserving string/template literal contents (e.g. so an
  * import specifier's quoted path stays readable). Each blanked character becomes a space
  * (newlines preserved) so remaining code characters keep their original offset. */

package/build/utils/pom-scope/testIdDiscovery.js

@@ -32,7 +32,16 @@ const ATTR_SELECTOR_RE = /\[\s*([A-Za-z][A-Za-z0-9_:-]*)\s*[~^$*|]?=\s*["']/g;
  * it admitted `data-auto-play` and `data-auto-height`, and `automation` already
  * covers the convention it was there for (`data-automation-id`).
  */
-const TEST_TOKENS = new Set(["test", "testid", "tests", "qa", "cy", "cypress", "e2e", "automation"]);
+const TEST_TOKENS = new Set([
+    "test",
+    "testid",
+    "tests",
+    "qa",
+    "cy",
+    "cypress",
+    "e2e",
+    "automation",
+]);
 /**
  * Whether a name plausibly denotes a test id.
  *
@@ -70,7 +79,10 @@ const OBSERVED_REPORT_LIMIT = 5;
 export async function discoverTestIdAttribute(root) {
     let files;
     try {
-        const [poms, specs] = await Promise.all([globPomFiles(root), globSpecFiles(root)]);
+        const [poms, specs] = await Promise.all([
+            globPomFiles(root),
+            globSpecFiles(root),
+        ]);
         files = [...new Set([...poms, ...specs])].slice(0, MAX_FILES);
     }
     catch {

package/build/utils/pom-verify/__fixtures__/af-style/asset-list.page.d.ts

@@ -1,4 +1,4 @@
-import { WorkflowFooter } from './workflow-footer.page.js';
+import { WorkflowFooter } from "./workflow-footer.page.js";
 export declare class AssetListPage {
     readonly footer: WorkflowFooter;
     constructor(page: any);

package/build/utils/pom-verify/__fixtures__/af-style/asset-list.page.js

@@ -1,5 +1,7 @@
-import { WorkflowFooter } from './workflow-footer.page.js';
+import { WorkflowFooter } from "./workflow-footer.page.js";
 export class AssetListPage {
     footer;
-    constructor(page) { this.footer = new WorkflowFooter(page); }
+    constructor(page) {
+        this.footer = new WorkflowFooter(page);
+    }
 }

package/build/utils/pom-verify/__fixtures__/af-style/report.iframe.page.js

@@ -1,4 +1,6 @@
 export class ReportIframePage {
     exportBtn;
-    constructor(frame) { this.exportBtn = frame.locator('[data-test="export-btn"]'); }
+    constructor(frame) {
+        this.exportBtn = frame.locator('[data-test="export-btn"]');
+    }
 }

package/build/utils/pom-verify/__fixtures__/af-style/workflow-footer.page.js

@@ -1,4 +1,6 @@
 export class WorkflowFooter {
     okBtn;
-    constructor(page) { this.okBtn = page.locator('[data-test="footer-ok-btn"]'); }
+    constructor(page) {
+        this.okBtn = page.locator('[data-test="footer-ok-btn"]');
+    }
 }

package/build/utils/pom-verify/bindings.js

@@ -156,7 +156,11 @@ export async function extractPomBindings(specContent, opts) {
                     }
                     for (const pmVar of pmVars) {
                         for (const [member, classFile] of memberMap) {
-                            pushBinding({ kind: "instance", name: `${pmVar}.${member}`, classFile });
+                            pushBinding({
+                                kind: "instance",
+                                name: `${pmVar}.${member}`,
+                                classFile,
+                            });
                         }
                         const accessRe = new RegExp(`\\b${escapeRegExp(pmVar)}\\.(\\w+)`, "g");
                         for (const am of spec.matchAll(accessRe)) {

package/build/utils/pom-verify/calls.js

@@ -33,8 +33,15 @@ export function extractPomCalls(specContent, bindings) {
             if (seen.has(key))
                 continue;
             seen.add(key);
-            found.push({ binding: binding.name, chain, strict: chain.length <= 1, pos: start });
+            found.push({
+                binding: binding.name,
+                chain,
+                strict: chain.length <= 1,
+                pos: start,
+            });
         }
     }
-    return found.sort((a, b) => a.pos - b.pos).map(({ binding, chain, strict }) => ({ binding, chain, strict }));
+    return found
+        .sort((a, b) => a.pos - b.pos)
+        .map(({ binding, chain, strict }) => ({ binding, chain, strict }));
 }

package/build/utils/pom-verify/verify.js

@@ -16,7 +16,18 @@ const NODE_CHECK_TIMEOUT_MS = 10_000;
 // mistake for method names (e.g. `if (...)`, `for (...)`) -- filtered out as noise, not parsed
 // around; see the "rough by design" comment on listMembers.
 const NON_MEMBER_KEYWORDS = new Set([
-    "if", "for", "while", "switch", "catch", "return", "else", "do", "function", "new", "typeof", "await",
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "return",
+    "else",
+    "do",
+    "function",
+    "new",
+    "typeof",
+    "await",
 ]);
 /**
  * Module-private, deliberately rough member lister: strips comments/strings then greps three
@@ -150,7 +161,9 @@ export async function verifyReuse(testFile, language) {
             // Candidates come from the whole searched closure, not just the binding's file: a
             // binding through a barrel has a member-less primary file, and the members the agent
             // could remap to live in the leaf classes the barrel re-exports.
-            const availableMembers = [...new Set((await Promise.all(searched.map(listMembers))).flat())];
+            const availableMembers = [
+                ...new Set((await Promise.all(searched.map(listMembers))).flat()),
+            ];
             if (availableMembers.length === 0) {
                 // "Not found, and I can enumerate nothing to remap to" is evidence about the
                 // VERIFIER's reach, not the member's existence. Emitting a violation here starts a
@@ -161,7 +174,12 @@ export async function verifyReuse(testFile, language) {
                 checkedCalls--;
                 continue;
             }
-            violations.push({ binding: call.binding, member, searched, availableMembers });
+            violations.push({
+                binding: call.binding,
+                member,
+                searched,
+                availableMembers,
+            });
         }
     }
     for (const u of unrecognized)
@@ -169,11 +187,15 @@ export async function verifyReuse(testFile, language) {
     let parseError;
     if (language === "javascript") {
         try {
-            await pExecFile("node", ["--check", testFile], { timeout: NODE_CHECK_TIMEOUT_MS });
+            await pExecFile("node", ["--check", testFile], {
+                timeout: NODE_CHECK_TIMEOUT_MS,
+            });
         }
         catch (err) {
             const e = err;
-            const stderr = e?.killed ? `node --check timed out after ${NODE_CHECK_TIMEOUT_MS}ms` : (e?.stderr ?? String(err));
+            const stderr = e?.killed
+                ? `node --check timed out after ${NODE_CHECK_TIMEOUT_MS}ms`
+                : (e?.stderr ?? String(err));
             parseError = stderr.slice(0, MAX_PARSE_ERROR_LEN);
         }
     }

package/build/utils/pr-comment-parser.js

@@ -53,7 +53,11 @@ const MULTI_METHOD_ENDPOINT_PATTERN = /\b((?:GET|POST|PUT|PATCH|DELETE)(?:\/(?:G
 function splitIntoSections(body) {
     const lines = body.split("\n");
     let currentSection = "rest";
-    const sections = { newTests: [], additionalRecs: [], rest: [] };
+    const sections = {
+        newTests: [],
+        additionalRecs: [],
+        rest: [],
+    };
     for (const line of lines) {
         if (SECTION_MARKERS.newTests.test(line)) {
             currentSection = "newTests";
@@ -155,10 +159,11 @@ function extractTestResultsSection(fullBody) {
             inTestResults = true;
             continue;
         }
-        if (inTestResults && (SECTION_MARKERS.testMaintenance.test(line) ||
-            SECTION_MARKERS.newTests.test(line) ||
-            SECTION_MARKERS.additionalRecs.test(line) ||
-            SECTION_MARKERS.issuesFound.test(line))) {
+        if (inTestResults &&
+            (SECTION_MARKERS.testMaintenance.test(line) ||
+                SECTION_MARKERS.newTests.test(line) ||
+                SECTION_MARKERS.additionalRecs.test(line) ||
+                SECTION_MARKERS.issuesFound.test(line))) {
             break;
         }
         if (inTestResults) {
@@ -176,7 +181,11 @@ function extractExecutionResults(body) {
         const file = fileMatches[i][0];
         const nearbyStatus = closestMatch(statusMatches, fileMatches[i].index, 150);
         const statusStr = nearbyStatus?.[1].toLowerCase();
-        const status = statusStr === "pass" ? "pass" : statusStr === "skipped" ? "skipped" : "fail";
+        const status = statusStr === "pass"
+            ? "pass"
+            : statusStr === "skipped"
+                ? "skipped"
+                : "fail";
         results.push({
             testFile: file,
             status,
@@ -205,7 +214,11 @@ export async function parsePRComments(repoOwner, repoName, prNumber, _token) {
     };
     let rawComments;
     try {
-        rawComments = execFileSync("gh", ["api", `repos/${repoOwner}/${repoName}/issues/${prNumber}/comments`, "--paginate"], {
+        rawComments = execFileSync("gh", [
+            "api",
+            `repos/${repoOwner}/${repoName}/issues/${prNumber}/comments`,
+            "--paginate",
+        ], {
             encoding: "utf-8",
             timeout: 15_000,
             stdio: ["pipe", "pipe", "pipe"],

package/build/utils/progress.d.ts

@@ -11,6 +11,6 @@ export type ProgressReporter = (progress: number, total: number, message: string
  * otherwise silently no-ops.
  *
  * Consolidates the identical closure that previously lived inline in multiple
- * progress-emitting tools (analyzeChanges, executeSkyrampTest, startTraceCollection).
+ * progress-emitting tools (analyzeChanges, startTraceCollection).
  */
 export declare function makeProgressReporter(extra: RequestHandlerExtra<ServerRequest, ServerNotification>): ProgressReporter;

package/build/utils/progress.js

@@ -4,7 +4,7 @@
  * otherwise silently no-ops.
  *
  * Consolidates the identical closure that previously lived inline in multiple
- * progress-emitting tools (analyzeChanges, executeSkyrampTest, startTraceCollection).
+ * progress-emitting tools (analyzeChanges, startTraceCollection).
  */
 export function makeProgressReporter(extra) {
     return async (progress, total, message) => {

package/build/utils/proxy-terminal.d.ts

@@ -1,2 +1,20 @@
+export declare function makeWindowsTerminalTitle(now?: Date): string;
+export declare function buildWindowsTerminalArgs(title: string): string[];
 export default function openProxyTerminal(): Promise<void>;
-export declare function closeProxyTerminal(): Promise<void>;
+export type TerminalCloseResult = {
+    closed: boolean;
+    title?: string;
+    reason?: string;
+    /**
+     * Windows still on screen that this process opened and could not close.
+     * Empty when there is nothing for the user to do; non-empty means say so.
+     */
+    orphanedTitles?: string[];
+};
+export type TerminalCloseOptions = {
+    /** How long to keep retrying taskkill before giving up. */
+    timeoutMs?: number;
+    /** Gap between taskkill attempts. */
+    pollMs?: number;
+};
+export declare function closeProxyTerminal(opts?: TerminalCloseOptions): Promise<TerminalCloseResult>;