@skyramp/mcp 0.3.6 → 0.3.8

package/build/utils/assertion-verify/metrics.js

@@ -0,0 +1,341 @@
+import * as path from "path";
+import { strippedSources } from "./strip-dispatch.js";
+import { balancedCloseIndex, lineOfOffset } from "./lint-types.js";
+const FINGERPRINT_CHAR_CAP = 120;
+const FINGERPRINT_SITE_CAP = 500;
+/** Exact-value matchers (camelCase and playwright-python snake_case twins). */
+const EXACT_MATCHERS = new Set([
+    "toHaveText",
+    "toHaveValue",
+    "toHaveAttribute",
+    "toHaveCount",
+    "toBeChecked",
+    "toHaveLength",
+    "toBe",
+    "toEqual",
+    "toStrictEqual",
+    "toBeUndefined",
+    "to_have_text",
+    "to_have_value",
+    "to_have_attribute",
+    "to_have_count",
+    "to_be_checked",
+    "to_have_length",
+    "to_be",
+    "to_equal",
+    "toHaveJSProperty",
+    "to_have_js_property",
+]);
+/** Pattern/partial/state matchers — weaker than exact values, but real
+ *  behavioral assertions: `toBeDisabled` after an action asserts a semantic
+ *  state transition, not mere presence, so it must clear the weak-additions
+ *  gate (weight ≥ 2). */
+const PARTIAL_MATCHERS = new Set([
+    "toMatch",
+    "toContainText",
+    "toHaveClass",
+    "toHaveURL",
+    "toContainEqual",
+    "toBeDisabled",
+    "toBeEnabled",
+    "toBeHidden",
+    "to_match",
+    "to_contain_text",
+    "to_have_class",
+    "to_have_url",
+    "to_be_disabled",
+    "to_be_enabled",
+    "to_be_hidden",
+]);
+/** Chain links to skip between `expect(...)` and the matcher. */
+const CHAIN_LINKS = new Set([
+    "not",
+    "resolves",
+    "rejects",
+    "soft",
+    "not_to",
+    "to",
+]);
+export function detectAssertionLanguage(testFile) {
+    switch (path.extname(testFile).toLowerCase()) {
+        case ".py":
+            return "python";
+        case ".ts":
+        case ".tsx":
+        case ".mts":
+            return "typescript";
+        case ".js":
+        case ".jsx":
+        case ".mjs":
+        case ".cjs":
+            return "javascript";
+        case ".java":
+            return "java";
+        default:
+            return undefined;
+    }
+}
+function matcherWeight(matcher) {
+    if (matcher === undefined)
+        return 1;
+    if (EXACT_MATCHERS.has(matcher))
+        return 3;
+    if (PARTIAL_MATCHERS.has(matcher))
+        return 2;
+    // Unknown matchers weigh 1, never 0 — any added assertion raises the score.
+    return 1;
+}
+function fingerprintOf(raw, start, end) {
+    return raw
+        .slice(start, end)
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, FINGERPRINT_CHAR_CAP);
+}
+function startOfLine(src, offset) {
+    const nl = src.lastIndexOf("\n", offset - 1);
+    return nl === -1 ? 0 : nl + 1;
+}
+/** expect-chain sites (`expect(...)[.not/.resolves/...].matcher(...)`), shared by
+ *  TS/JS and playwright-python. Scans stripped content, fingerprints from raw. */
+function expectSites(raw, stripped) {
+    const sites = [];
+    const re = /\bexpect(?:\s*\.\s*soft)?\s*\(/g;
+    let m;
+    while ((m = re.exec(stripped)) !== null) {
+        const openIdx = m.index + m[0].length - 1;
+        const argClose = balancedCloseIndex(stripped, openIdx);
+        if (argClose === -1)
+            continue;
+        // Walk the chain past link members (.not / .resolves / …) to the matcher.
+        let cursor = argClose + 1;
+        let matcher;
+        for (;;) {
+            const link = /^\s*\.\s*([A-Za-z_]\w*)/.exec(stripped.slice(cursor));
+            if (!link)
+                break;
+            cursor += link[0].length;
+            if (CHAIN_LINKS.has(link[1]))
+                continue;
+            matcher = link[1];
+            break;
+        }
+        // Statement extent: start of the site's line through the matcher call's
+        // closing paren (or the expect close when there is no chained call).
+        let stmtEnd = argClose + 1;
+        if (matcher !== undefined) {
+            const matcherOpen = /^\s*\(/.exec(stripped.slice(cursor));
+            if (matcherOpen) {
+                const close = balancedCloseIndex(stripped, cursor + matcherOpen[0].length - 1);
+                if (close !== -1)
+                    stmtEnd = close + 1;
+            }
+            else {
+                stmtEnd = cursor;
+            }
+        }
+        const stmtStart = startOfLine(raw, m.index);
+        sites.push({
+            line: lineOfOffset(stripped, m.index),
+            matcher,
+            weight: matcherWeight(matcher),
+            fingerprint: fingerprintOf(raw, stmtStart, stmtEnd),
+        });
+        re.lastIndex = Math.max(re.lastIndex, argClose + 1);
+    }
+    return sites;
+}
+/** Weight of a bare python `assert` statement, classified by its operators. */
+function pythonAssertWeight(stmt) {
+    if (stmt.includes("==") ||
+        stmt.includes("!=") ||
+        // Same tier rule (and same spelling tolerance) as the node-assert scanner
+        // — the two had drifted, scoring an identical schema check 3 in JS and 1
+        // in python when spelled checkSchema.
+        /\bcheck_?schema\s*\(/i.test(stmt))
+        return 3;
+    if (/\bre\s*\.\s*(?:match|fullmatch)\s*\(|\.startswith\s*\(|\bin\b/.test(stmt))
+        return 2;
+    return 1;
+}
+function pythonAssertSites(raw, stripped) {
+    const sites = [];
+    const lines = stripped.split("\n");
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^\s*assert\b/.test(line)) {
+            // Extend across paren/backslash continuations (bounded) so one multi-line
+            // assert counts once and fingerprints whole.
+            let stmt = line;
+            let last = i;
+            const depthOf = (s) => (s.match(/[([{]/g)?.length ?? 0) - (s.match(/[)\]}]/g)?.length ?? 0);
+            let depth = depthOf(stmt);
+            while ((depth > 0 || stmt.trimEnd().endsWith("\\")) &&
+                last + 1 < lines.length &&
+                last - i < 10) {
+                last++;
+                stmt += "\n" + lines[last];
+                depth = depthOf(stmt);
+            }
+            const stmtEnd = offset + stmt.length;
+            sites.push({
+                line: i + 1,
+                weight: pythonAssertWeight(stmt),
+                fingerprint: fingerprintOf(raw, offset + (line.length - line.trimStart().length), stmtEnd),
+            });
+            i = last;
+            offset = stmtEnd + 1;
+            continue;
+        }
+        offset += line.length + 1;
+    }
+    return sites;
+}
+// Node's assert module — the idiom JS codegen actually emits
+// (`assert.strictEqual(...)`, `assert.ok(checkSchema(...))`); Playwright
+// `expect()` never appears in those files, so without this scanner every JS
+// spec scored 0 sites and the strength gate false-failed on 0 > 0
+// (found by running the verifier over the javascript/playwright goldens).
+const NODE_ASSERT_RE = /(?<![\w$.])assert\s*\.\s*([\w$]+)\s*\(/g;
+// Exact-value methods score like their expect() equivalents (toBe/toEqual=3);
+// assert.match is a pattern check (2); everything else — ok, notStrictEqual
+// (the "not null" idiom), throws — is existence-tier (1).
+const NODE_ASSERT_EXACT = new Set([
+    "strictEqual",
+    "deepStrictEqual",
+    "equal",
+    "deepEqual",
+]);
+/** Shared regex-scan-and-fingerprint loop for call-shaped assertion dialects
+ *  (node assert, java) — they differ only in the regex and the weighting. */
+function callSites(raw, stripped, re, matcherOf, weightOf) {
+    const sites = [];
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(stripped)) !== null) {
+        const close = balancedCloseIndex(stripped, m.index + m[0].length - 1);
+        const args = close === -1 ? "" : stripped.slice(m.index + m[0].length, close);
+        sites.push({
+            line: lineOfOffset(stripped, m.index),
+            matcher: matcherOf(m),
+            weight: weightOf(m, args),
+            fingerprint: fingerprintOf(raw, startOfLine(raw, m.index), close === -1 ? m.index + m[0].length : close + 1),
+        });
+    }
+    return sites;
+}
+function nodeAssertSites(raw, stripped) {
+    return callSites(raw, stripped, NODE_ASSERT_RE, (m) => `assert.${m[1]}`, 
+    // assert.ok(checkSchema(...)) is a full-shape check — exact tier, same
+    // treatment as check_schema in the python scanner.
+    (m, args) => NODE_ASSERT_EXACT.has(m[1])
+        ? 3
+        : /\bcheck_?schema\s*\(/i.test(args)
+            ? 3
+            : m[1] === "match"
+                ? 2
+                : 1);
+}
+const JAVA_ASSERT_RE = /\b(assertEquals|assertNotEquals|assertTrue|assertFalse|assertNull|assertNotNull|assertThat|assertArrayEquals)\s*\(/g;
+function javaAssertSites(raw, stripped) {
+    return callSites(raw, stripped, JAVA_ASSERT_RE, (m) => m[1], (m) => (m[1] === "assertEquals" || m[1] === "assertArrayEquals" ? 3 : 1));
+}
+/**
+ * The assertion's SUBJECT — what it asserts about — recovered from a fingerprint
+ * (`expect(SUBJECT).matcher(...)` arg, or a python assert's left-hand side).
+ * Correlating subjects across baseline and current fingerprints is what tells a
+ * REPLACED assertion (subject still asserted, usually more strongly) from a
+ * REMOVED one (subject lost all coverage). Undefined when unrecoverable (e.g.
+ * truncated fingerprint) — callers treat that conservatively.
+ */
+export function subjectOf(fingerprint) {
+    const expectMatch = /\bexpect(?:\s*\.\s*soft)?\s*\(/.exec(fingerprint);
+    if (expectMatch) {
+        const openIdx = expectMatch.index + expectMatch[0].length - 1;
+        const close = balancedCloseIndex(fingerprint, openIdx);
+        if (close === -1)
+            return undefined;
+        return fingerprint.slice(openIdx + 1, close).replace(/\s+/g, "");
+    }
+    // Node assert: the subject is the first top-level argument
+    // (`assert.strictEqual(SUBJECT, expected, msg?)`, `assert.ok(SUBJECT, msg?)`).
+    const nodeAssert = /(?<![\w$.])assert\s*\.\s*[\w$]+\s*\(/.exec(fingerprint);
+    if (nodeAssert) {
+        const openIdx = nodeAssert.index + nodeAssert[0].length - 1;
+        const close = balancedCloseIndex(fingerprint, openIdx);
+        const args = fingerprint.slice(openIdx + 1, close === -1 ? undefined : close);
+        let depth = 0;
+        let end = args.length;
+        for (let i = 0; i < args.length; i++) {
+            const c = args[i];
+            if (c === "(" || c === "[" || c === "{")
+                depth++;
+            else if (c === ")" || c === "]" || c === "}")
+                depth--;
+            else if (depth === 0 && c === ",") {
+                end = i;
+                break;
+            }
+        }
+        const subject = args.slice(0, end).replace(/\s+/g, "");
+        return subject.length > 0 ? subject : undefined;
+    }
+    const assertPrefix = /^assert\s+/.exec(fingerprint);
+    if (assertPrefix) {
+        // Depth-aware scan to the first TOP-LEVEL comparison operator, `is`/`in`,
+        // or comma (an assert message) — commas inside call args must not split.
+        const rest = fingerprint.slice(assertPrefix[0].length);
+        let depth = 0;
+        let end = rest.length;
+        for (let i = 0; i < rest.length; i++) {
+            const c = rest[i];
+            if (c === "(" || c === "[" || c === "{")
+                depth++;
+            else if (c === ")" || c === "]" || c === "}")
+                depth--;
+            else if (depth === 0) {
+                if (c === "," ||
+                    c === "<" ||
+                    c === ">" ||
+                    (c === "=" && rest[i + 1] === "=") ||
+                    (c === "!" && rest[i + 1] === "=") ||
+                    rest.startsWith(" is ", i) ||
+                    rest.startsWith(" in ", i)) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        const lhs = rest.slice(0, end).replace(/\s+/g, "");
+        return lhs.length > 0 ? lhs : undefined;
+    }
+    return undefined;
+}
+export function computeAssertionMetrics(content, language) {
+    let sites;
+    const { stripped } = strippedSources(content, language);
+    if (language === "python") {
+        sites = [
+            ...pythonAssertSites(content, stripped),
+            ...expectSites(content, stripped),
+        ];
+    }
+    else if (language === "java") {
+        sites = javaAssertSites(content, stripped);
+    }
+    else {
+        sites = [
+            ...expectSites(content, stripped),
+            ...nodeAssertSites(content, stripped),
+        ];
+    }
+    return {
+        count: sites.length,
+        strengthScore: sites.reduce((sum, s) => sum + s.weight, 0),
+        fingerprints: sites
+            .slice(0, FINGERPRINT_SITE_CAP)
+            .map((s) => s.fingerprint),
+        sites,
+    };
+}

package/build/utils/assertion-verify/python-strip.d.ts

@@ -0,0 +1,6 @@
+/** Blanks `#` comments only, preserving string contents. */
+export declare function stripPythonComments(src: string): string;
+/** Blanks string literal contents only, preserving comments. */
+export declare function stripPythonStrings(src: string): string;
+/** Blanks both comments and strings. */
+export declare function stripPythonCommentsAndStrings(src: string): string;

package/build/utils/assertion-verify/python-strip.js

@@ -0,0 +1,75 @@
+/**
+ * Python twin of `src/utils/pom-scope/strip.ts`: one lexer-lite pass classifying
+ * `#` comments and string literals ('...', "...", '''...''', """...""", with
+ * prefixes like f/r/b treated as part of plain strings). Blanked characters
+ * become spaces (newlines preserved) so surviving code keeps its offsets.
+ */
+function classifySpans(src) {
+    const spans = [];
+    let i = 0;
+    const n = src.length;
+    while (i < n) {
+        const c = src[i];
+        if (c === "#") {
+            const start = i;
+            while (i < n && src[i] !== "\n")
+                i++;
+            spans.push({ kind: "comment", start, end: i });
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            const quote = c;
+            const triple = src.startsWith(quote.repeat(3), i);
+            const closer = triple ? quote.repeat(3) : quote;
+            const start = i;
+            i += closer.length;
+            let closed = false;
+            while (i < n) {
+                if (src[i] === "\\" && i + 1 < n) {
+                    i += 2;
+                    continue;
+                }
+                if (src.startsWith(closer, i)) {
+                    i += closer.length;
+                    closed = true;
+                    break;
+                }
+                // Single-quoted strings can't span a raw newline; treat an unclosed
+                // opener as a stray quote rather than blanking to end of file.
+                if (src[i] === "\n" && !triple)
+                    break;
+                i++;
+            }
+            if (!closed && !triple) {
+                i = start + 1;
+                continue;
+            }
+            spans.push({ kind: "string", start, end: i });
+            continue;
+        }
+        i++;
+    }
+    return spans;
+}
+function blankSpans(src, spans) {
+    if (spans.length === 0)
+        return src;
+    const out = src.split("");
+    for (const { start, end } of spans) {
+        for (let i = start; i < end; i++)
+            out[i] = src[i] === "\n" ? "\n" : " ";
+    }
+    return out.join("");
+}
+/** Blanks `#` comments only, preserving string contents. */
+export function stripPythonComments(src) {
+    return blankSpans(src, classifySpans(src).filter((s) => s.kind === "comment"));
+}
+/** Blanks string literal contents only, preserving comments. */
+export function stripPythonStrings(src) {
+    return blankSpans(src, classifySpans(src).filter((s) => s.kind === "string"));
+}
+/** Blanks both comments and strings. */
+export function stripPythonCommentsAndStrings(src) {
+    return blankSpans(src, classifySpans(src));
+}

package/build/utils/assertion-verify/strip-dispatch.d.ts

@@ -0,0 +1,19 @@
+import type { AssertionLanguage } from "./metrics.js";
+/**
+ * The one place that knows how to strip a source per language — including the
+ * rule that JS/TS regex literals must be blanked BEFORE string stripping (an
+ * apostrophe inside a regex otherwise opens a phantom string span). Before
+ * this module, that rule was re-asserted by hand at seven call sites, and one
+ * verify pass re-stripped the same content 5–8 times; the one-entry memo makes
+ * repeated calls on the same content free (metrics + every lint module + the
+ * marker scan all run on one file per pass).
+ */
+export interface StrippedSources {
+    /** Comments blanked; strings intact. */
+    commentless: string;
+    /** Comments AND strings blanked (JS/TS: regex literals blanked first). */
+    stripped: string;
+    /** Strings blanked; comments intact (the marker scan reads comments). */
+    stringless: string;
+}
+export declare function strippedSources(content: string, language: AssertionLanguage): StrippedSources;

package/build/utils/assertion-verify/strip-dispatch.js

@@ -0,0 +1,42 @@
+import { stripComments, stripCommentsAndStrings, stripStrings, } from "../pom-scope/strip.js";
+import { stripPythonComments, stripPythonCommentsAndStrings, stripPythonStrings, } from "./python-strip.js";
+import { blankJsRegexLiterals } from "./js-regex-blank.js";
+let memoKeyContent;
+let memoKeyLanguage;
+let memoValue;
+export function strippedSources(content, language) {
+    if (memoValue !== undefined &&
+        memoKeyContent === content &&
+        memoKeyLanguage === language) {
+        return memoValue;
+    }
+    let value;
+    if (language === "python") {
+        value = {
+            commentless: stripPythonComments(content),
+            stripped: stripPythonCommentsAndStrings(content),
+            stringless: stripPythonStrings(content),
+        };
+    }
+    else if (language === "java") {
+        // Java gets the JS/TS comment/string grammar (same tokens) minus the
+        // regex-literal pre-pass, which does not exist in Java.
+        value = {
+            commentless: stripComments(content),
+            stripped: stripCommentsAndStrings(content),
+            stringless: stripStrings(content),
+        };
+    }
+    else {
+        const blanked = blankJsRegexLiterals(content);
+        value = {
+            commentless: stripComments(content),
+            stripped: stripCommentsAndStrings(blanked),
+            stringless: stripStrings(blanked),
+        };
+    }
+    memoKeyContent = content;
+    memoKeyLanguage = language;
+    memoValue = value;
+    return value;
+}

package/build/utils/assertion-verify/ui-lints.d.ts

@@ -0,0 +1,8 @@
+import type { AssertionLanguage } from "./metrics.js";
+import { type LintFinding, type LintOptions } from "./lint-types.js";
+/** UI (Playwright) lints. Python (playwright-python) UI specs deliberately get
+ *  the site-scoped lints only: the structural rules' patterns and accept-lists
+ *  are JS/TS-specific (imports, waitForResponse shapes, expect matcher accept
+ *  forms), and porting them without a python golden corpus to validate against
+ *  would recreate the false-block class review round 2 removed. Pinned by test. */
+export declare function lintUiSpec(raw: string, language: AssertionLanguage, opts?: LintOptions): LintFinding[];