@skyramp/mcp 0.3.0-rc.1 → 0.3.0

package/build/utils/fileWalk.test.js

@@ -0,0 +1,252 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { collectFiles, walkDir, walkSourceFiles } from "./fileWalk.js";
+/** Materialize a file tree under a fresh temp dir. Keys are relative paths;
+ * a value of `null` creates an (empty) directory instead of a file. */
+function makeTree(files) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "filewalk-"));
+    for (const [rel, content] of Object.entries(files)) {
+        const abs = path.join(root, rel);
+        if (content === null) {
+            fs.mkdirSync(abs, { recursive: true });
+        }
+        else {
+            fs.mkdirSync(path.dirname(abs), { recursive: true });
+            fs.writeFileSync(abs, content);
+        }
+    }
+    return root;
+}
+/** Sort + make paths relative to root for stable comparison. */
+function rel(root, abs) {
+    return abs.map((p) => path.relative(root, p).replace(/\\/g, "/")).sort();
+}
+// `chmod 000` only makes a directory unreadable where the OS enforces the
+// permission bits: not on Windows, and not for root (which bypasses them). Skip
+// the best-effort-on-unreadable-dir tests where the setup can't actually fail a
+// readdir, rather than let them false-fail. `it`/`it.skip` chosen at load time.
+const permsEnforced = process.platform !== "win32" &&
+    (typeof process.getuid !== "function" || process.getuid() !== 0);
+const itIfPerms = permsEnforced ? it : it.skip;
+/** Collect the absolute file paths a walkDir generator yields. */
+function walkPaths(root, opts) {
+    const seen = [];
+    for (const [, full] of walkDir(root, opts))
+        seen.push(full);
+    return seen;
+}
+describe("walkDir", () => {
+    it("yields every file depth-first as [entry, absolute path]", () => {
+        const root = makeTree({
+            "a.txt": "a",
+            "sub/b.txt": "b",
+            "sub/deep/c.txt": "c",
+        });
+        const seen = [];
+        for (const [entry, full] of walkDir(root)) {
+            expect(entry.isFile()).toBe(true);
+            expect(path.isAbsolute(full)).toBe(true);
+            seen.push(full);
+        }
+        expect(rel(root, seen)).toEqual(["a.txt", "sub/b.txt", "sub/deep/c.txt"]);
+    });
+    it("yields only files, never directory entries", () => {
+        const root = makeTree({ "sub/b.txt": "b", emptydir: null });
+        const names = [...walkDir(root)].map(([entry]) => entry.name);
+        expect(names).toEqual(["b.txt"]);
+    });
+    it("honors maxDepth = 0 (root files only, no descent)", () => {
+        const root = makeTree({ "a.txt": "a", "sub/b.txt": "b" });
+        expect(rel(root, walkPaths(root, { maxDepth: 0 }))).toEqual(["a.txt"]);
+    });
+    it("honors maxDepth = 1 (root + one level down)", () => {
+        const root = makeTree({
+            "a.txt": "a",
+            "sub/b.txt": "b",
+            "sub/deep/c.txt": "c",
+        });
+        expect(rel(root, walkPaths(root, { maxDepth: 1 }))).toEqual([
+            "a.txt",
+            "sub/b.txt",
+        ]);
+    });
+    it("skips directories for which shouldSkipDir returns true", () => {
+        const root = makeTree({
+            "keep/a.txt": "a",
+            "node_modules/x.txt": "x",
+        });
+        const out = walkPaths(root, {
+            shouldSkipDir: (entry) => entry.name === "node_modules",
+        });
+        expect(rel(root, out)).toEqual(["keep/a.txt"]);
+    });
+    it("passes the directory's absolute path to shouldSkipDir", () => {
+        const root = makeTree({ "sub/a.txt": "a" });
+        [
+            ...walkDir(root, {
+                shouldSkipDir: (entry, full) => {
+                    expect(path.isAbsolute(full)).toBe(true);
+                    expect(path.basename(full)).toBe(entry.name);
+                    return false;
+                },
+            }),
+        ];
+    });
+    it("stops immediately when the consumer breaks (no further reads)", () => {
+        const root = makeTree({
+            "1.txt": "",
+            "2.txt": "",
+            "3.txt": "",
+            "sub/4.txt": "",
+        });
+        const seen = [];
+        for (const [, full] of walkDir(root)) {
+            seen.push(full);
+            break; // stop after the very first file
+        }
+        expect(seen.length).toBe(1);
+    });
+    it("yields all files when the consumer never breaks", () => {
+        const root = makeTree({ "1.txt": "", "2.txt": "" });
+        expect(walkPaths(root).length).toBe(2);
+    });
+    itIfPerms("is best-effort: an unreadable subdirectory is skipped, not fatal", () => {
+        const root = makeTree({ "a.txt": "a", "bad/b.txt": "b", "c.txt": "c" });
+        const badDir = path.join(root, "bad");
+        fs.chmodSync(badDir, 0o000);
+        try {
+            // Should not throw despite `bad` being unreadable, and should skip its
+            // contents while still visiting siblings.
+            expect(rel(root, walkPaths(root))).toEqual(["a.txt", "c.txt"]);
+        }
+        finally {
+            fs.chmodSync(badDir, 0o755);
+        }
+    });
+    it("does not throw when the root itself is unreadable/missing", () => {
+        expect(() => walkPaths(path.join(os.tmpdir(), "filewalk-does-not-exist-xyz"))).not.toThrow();
+    });
+});
+describe("walkSourceFiles (characterization — existing contract)", () => {
+    it("collects only files matching one of the extensions, as absolute paths", () => {
+        const root = makeTree({
+            "a.ts": "",
+            "b.tsx": "",
+            "c.js": "",
+            "d.py": "",
+            "sub/e.ts": "",
+        });
+        const out = walkSourceFiles(root, {
+            extensions: [".ts", ".tsx"],
+            skipDirs: new Set(),
+        });
+        expect(out.every((p) => path.isAbsolute(p))).toBe(true);
+        expect(rel(root, out)).toEqual(["a.ts", "b.tsx", "sub/e.ts"]);
+    });
+    it("skips directories named in skipDirs (matched on basename)", () => {
+        const root = makeTree({
+            "a.ts": "",
+            "node_modules/x.ts": "",
+            "src/b.ts": "",
+        });
+        const out = walkSourceFiles(root, {
+            extensions: [".ts"],
+            skipDirs: new Set(["node_modules"]),
+        });
+        expect(rel(root, out)).toEqual(["a.ts", "src/b.ts"]);
+    });
+    it("stops at exactly `limit` files when the cap is hit", () => {
+        const root = makeTree({
+            "a.ts": "",
+            "b.ts": "",
+            "c.ts": "",
+            "d.ts": "",
+        });
+        const out = walkSourceFiles(root, {
+            extensions: [".ts"],
+            skipDirs: new Set(),
+            limit: 2,
+        });
+        expect(out.length).toBe(2);
+    });
+    it("returns all matches when under the limit", () => {
+        const root = makeTree({ "a.ts": "", "b.ts": "" });
+        const out = walkSourceFiles(root, {
+            extensions: [".ts"],
+            skipDirs: new Set(),
+            limit: 100,
+        });
+        expect(out.length).toBe(2);
+    });
+    it("does NOT skip dotfile directories by default", () => {
+        const root = makeTree({ ".hidden/a.ts": "", "b.ts": "" });
+        const out = walkSourceFiles(root, {
+            extensions: [".ts"],
+            skipDirs: new Set(),
+        });
+        expect(rel(root, out)).toEqual([".hidden/a.ts", "b.ts"]);
+    });
+    itIfPerms("is best-effort on unreadable directories", () => {
+        const root = makeTree({ "a.ts": "", "bad/b.ts": "" });
+        const badDir = path.join(root, "bad");
+        fs.chmodSync(badDir, 0o000);
+        try {
+            const out = walkSourceFiles(root, {
+                extensions: [".ts"],
+                skipDirs: new Set(),
+            });
+            expect(rel(root, out)).toEqual(["a.ts"]);
+        }
+        finally {
+            fs.chmodSync(badDir, 0o755);
+        }
+    });
+});
+describe("collectFiles", () => {
+    it("collects files matching the predicate as absolute paths", () => {
+        const root = makeTree({ "a.dart": "", "b.txt": "", "sub/c.dart": "" });
+        const out = collectFiles(root, {
+            match: (entry) => entry.name.endsWith(".dart"),
+        });
+        expect(out.every((p) => path.isAbsolute(p))).toBe(true);
+        expect(rel(root, out)).toEqual(["a.dart", "sub/c.dart"]);
+    });
+    it("passes the absolute path to the matcher", () => {
+        const root = makeTree({ "keep/x.ts": "", "modules/y/index.ts": "" });
+        const out = collectFiles(root, {
+            match: (_entry, full) => full.includes(`${path.sep}modules${path.sep}`),
+        });
+        expect(rel(root, out)).toEqual(["modules/y/index.ts"]);
+    });
+    it("returns exactly `limit` files when the cap is hit", () => {
+        const root = makeTree({ "a.ts": "", "b.ts": "", "c.ts": "" });
+        const out = collectFiles(root, {
+            match: (entry) => entry.name.endsWith(".ts"),
+            limit: 2,
+        });
+        expect(out.length).toBe(2);
+    });
+    it("returns nothing for `limit: 0` (does not collect a single file)", () => {
+        const root = makeTree({ "a.ts": "", "b.ts": "" });
+        const out = collectFiles(root, {
+            match: () => true,
+            limit: 0,
+        });
+        expect(out).toEqual([]);
+    });
+    it("forwards maxDepth and shouldSkipDir to the walk", () => {
+        const root = makeTree({
+            "a.ts": "",
+            "skip/b.ts": "",
+            "sub/deep/c.ts": "",
+        });
+        const out = collectFiles(root, {
+            match: (entry) => entry.name.endsWith(".ts"),
+            maxDepth: 1,
+            shouldSkipDir: (entry) => entry.name === "skip",
+        });
+        // maxDepth: 1 excludes sub/deep/c.ts; shouldSkipDir excludes skip/b.ts.
+        expect(rel(root, out)).toEqual(["a.ts"]);
+    });
+});

package/build/utils/frontendIntegration.js

@@ -28,6 +28,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { isTestFile } from "../prompts/test-recommendation/scopeAssessment.js";
 import { logger } from "./logger.js";
+import { walkDir } from "./fileWalk.js";
 import { buildPathSignatures } from "./pathSignatures.js";
 import { IntegrationReason } from "../types/FrontendIntegration.js";
 const MAX_IMPORTERS = 10;
@@ -117,48 +118,31 @@ function manualWalkGrep(repositoryPath, signatures) {
     const results = [];
     let filesScanned = 0;
     let truncated = false;
-    const stack = [repositoryPath];
-    walk: while (stack.length > 0) {
+    const shouldSkipDir = (_entry, full) => {
+        // EXCLUDED_DIR_PATTERN matches on the "/"-normalized relative path.
+        const rel = path.relative(repositoryPath, full).replace(/\\/g, "/");
+        return EXCLUDED_DIR_PATTERN.test(rel + "/");
+    };
+    for (const [entry, abs] of walkDir(repositoryPath, { shouldSkipDir })) {
+        if (!FRONTEND_SOURCE_EXT_PATTERN.test(entry.name))
+            continue;
         if (filesScanned >= MAX_FILES_WALKED) {
             truncated = true;
-            break;
+            break; // stop the entire walk
         }
-        const dir = stack.pop();
-        let entries;
+        filesScanned++;
+        // Normalize to forward slashes: on Windows, path.relative() returns
+        // "\\"-separated paths, but isTestFile assumes "/".
+        const rel = path.relative(repositoryPath, abs).replace(/\\/g, "/");
         try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
+            if (fs.statSync(abs).size > MAX_FILE_SIZE_BYTES)
+                continue;
+            const content = fs.readFileSync(abs, "utf-8");
+            if (signatures.some((s) => content.includes(s)))
+                results.push(rel);
         }
         catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const abs = path.join(dir, entry.name);
-            // Normalize to forward slashes: on Windows, path.relative() returns
-            // "\\"-separated paths, but EXCLUDED_DIR_PATTERN/isTestFile assume "/".
-            const rel = path.relative(repositoryPath, abs).replace(/\\/g, "/");
-            if (entry.isDirectory()) {
-                if (EXCLUDED_DIR_PATTERN.test(rel + "/"))
-                    continue;
-                stack.push(abs);
-                continue;
-            }
-            if (!FRONTEND_SOURCE_EXT_PATTERN.test(entry.name))
-                continue;
-            if (filesScanned >= MAX_FILES_WALKED) {
-                truncated = true;
-                break walk;
-            }
-            filesScanned++;
-            try {
-                if (fs.statSync(abs).size > MAX_FILE_SIZE_BYTES)
-                    continue;
-                const content = fs.readFileSync(abs, "utf-8");
-                if (signatures.some((s) => content.includes(s)))
-                    results.push(rel);
-            }
-            catch {
-                continue;
-            }
+            // Unreadable/vanished file — skip it, keep scanning.
         }
     }
     if (truncated && results.length === 0) {

package/build/utils/frontendSelectors.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Frontend selector extraction for UI-test-maintenance discovery (Pass 3, "selector-edge").
+ *
+ * Playwright/Cypress page objects couple to a changed component by SELECTOR — a
+ * `data-testid` value or a CSS class token — not by filename or by `import`. So the
+ * filename-token (pass 1) and import-edge (pass 2) promotion signals in
+ * TestDiscoveryService Step 2 both miss them: a page object `table.component.ts` shares
+ * no name token with the changed `CascadeFields.tsx` and does not import it — it selects
+ * `.t--table-filter-columns-dropdown` at runtime.
+ *
+ * This module extracts the selector literals that a frontend diff added OR removed, so
+ * discovery can promote any existing test/page-object whose body still references one of
+ * them. Both sides of a rename are captured deliberately: a page object that has NOT been
+ * updated still contains the OLD value, so matching the removed literal is what surfaces
+ * the test that needs maintenance.
+ *
+ * This is the frontend analog of importerHop's `extractChangedSymbols` (backend type
+ * names) — kept in its own frontend-scoped module rather than in the backend-resource
+ * importerHop, per the codebase convention of keeping domain vocabularies local.
+ */
+export declare const MAX_CHANGED_SELECTORS = 80;
+/**
+ * Extract selector literals added or removed in a single file's diff slice.
+ *
+ * Two complementary passes over the changed (`+`/`-`) lines, excluding the `+++`/`---`
+ * file headers:
+ *   1. Explicit test-facing attribute/API values: `data-testid` / `data-test` /
+ *      `data-test-id` / `data-cy` / `data-qa` attribute values and `getByTestId(...)`
+ *      arguments (trusted — accepts camelCase or single-delimiter ids).
+ *   2. Distinctive kebab / BEM class tokens anywhere on the line (>= 2 hyphens or `--`),
+ *      which catches CSS-class-based coupling (`t--table-filter-columns-dropdown`,
+ *      `ads-button--primary`).
+ */
+export declare function extractChangedSelectors(fileDiff: string): string[];

package/build/utils/frontendSelectors.js

@@ -0,0 +1,124 @@
+/**
+ * Frontend selector extraction for UI-test-maintenance discovery (Pass 3, "selector-edge").
+ *
+ * Playwright/Cypress page objects couple to a changed component by SELECTOR — a
+ * `data-testid` value or a CSS class token — not by filename or by `import`. So the
+ * filename-token (pass 1) and import-edge (pass 2) promotion signals in
+ * TestDiscoveryService Step 2 both miss them: a page object `table.component.ts` shares
+ * no name token with the changed `CascadeFields.tsx` and does not import it — it selects
+ * `.t--table-filter-columns-dropdown` at runtime.
+ *
+ * This module extracts the selector literals that a frontend diff added OR removed, so
+ * discovery can promote any existing test/page-object whose body still references one of
+ * them. Both sides of a rename are captured deliberately: a page object that has NOT been
+ * updated still contains the OLD value, so matching the removed literal is what surfaces
+ * the test that needs maintenance.
+ *
+ * This is the frontend analog of importerHop's `extractChangedSymbols` (backend type
+ * names) — kept in its own frontend-scoped module rather than in the backend-resource
+ * importerHop, per the codebase convention of keeping domain vocabularies local.
+ */
+// Bound the extracted set so a large diff can't produce an unbounded match list. The
+// downstream promotion is separately capped by MAX_UI_PROMOTED, so this is a belt on the
+// literal set itself. Exported so the caller can detect + log when a single file's
+// extraction is truncated by this cap.
+export const MAX_CHANGED_SELECTORS = 80;
+// Utility / design-token CSS classes (Tailwind/Bootstrap-style) are ALSO multi-hyphen kebab
+// tokens, but they are shared *styling* vocabulary, not component identity — matching them
+// floods Pass 3, because snapshot files (`__snapshots__/*.snap`) serialize `className`
+// verbatim, so an unrelated component's snapshot reuses the same class (e.g. `text-gray-500`).
+// Reject the two dominant utility shapes on the untrusted path: a numeric scale suffix
+// (`text-gray-500`, `bg-blue-600`, `grid-cols-3`) and common non-numeric utility roots
+// (`flex-row-reverse`, `space-x-…`). BEM component classes (`ads-button--primary`, `t--…`)
+// and semantic identifiers (`confirmation-modal-confirm-button`) are kept.
+const COMMON_CSS_SELECTOR_TOKENS = /-\d+$|^(?:flex|grid|space|gap|order|col|row|inset|translate|scale|rotate|divide|place|self|content|justify|items|auto)-/;
+/**
+ * True if a token is a distinctive selector literal worth matching against test bodies.
+ * `trusted` = extracted from an explicit test-facing attribute (data-testid / getByTestId),
+ * where a single delimiter or camelCase boundary is enough. Untrusted (a bare kebab/BEM token
+ * found anywhere on the line) requires a BEM `--`, or >= 2 hyphens that don't look like a
+ * utility/design-token class — otherwise shared styling classes flood promotion.
+ */
+function isDistinctiveSelector(token, trusted) {
+    if (token.length < 6)
+        return false;
+    const hyphens = (token.match(/-/g) ?? []).length;
+    const hasBEM = token.includes("--");
+    if (trusted) {
+        // A test id: any structural signal (delimiter or camelCase) qualifies — single-word
+        // ids like "submit" (6 chars, so past the length gate) are dropped by the structural
+        // requirement alone: no hyphen, underscore, or camelCase boundary.
+        return hyphens > 0 || token.includes("_") || /[a-z][A-Z]/.test(token);
+    }
+    return hasBEM || (hyphens >= 2 && !COMMON_CSS_SELECTOR_TOKENS.test(token));
+}
+/**
+ * Extract selector literals added or removed in a single file's diff slice.
+ *
+ * Two complementary passes over the changed (`+`/`-`) lines, excluding the `+++`/`---`
+ * file headers:
+ *   1. Explicit test-facing attribute/API values: `data-testid` / `data-test` /
+ *      `data-test-id` / `data-cy` / `data-qa` attribute values and `getByTestId(...)`
+ *      arguments (trusted — accepts camelCase or single-delimiter ids).
+ *   2. Distinctive kebab / BEM class tokens anywhere on the line (>= 2 hyphens or `--`),
+ *      which catches CSS-class-based coupling (`t--table-filter-columns-dropdown`,
+ *      `ads-button--primary`).
+ */
+export function extractChangedSelectors(fileDiff) {
+    const out = new Set();
+    // Require a quote immediately before the value so only string LITERALS are captured —
+    // `data-testid="x"`, `data-testid={'x'}`, `data-testid={`x`}`. This deliberately skips
+    // non-literal expressions like `data-testid={someVar}`, which would otherwise inject a
+    // variable name into the selector set and cause noisy promotion matches.
+    // Require a quote/backtick on BOTH sides so only FULLY-literal values are captured —
+    // `data-testid="x"`, `data-testid={'x'}`, `data-testid={`x`}`. The closing delimiter
+    // deliberately rejects interpolated template literals (`data-testid={`members-${id}`}`),
+    // which would otherwise leak a partial prefix (`members-`) into the selector set.
+    // eslint-disable-next-line no-useless-escape
+    const ATTR = /\bdata-(?:test-?id|test|cy|qa)\b\s*=\s*\{?\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/g;
+    const GET_BY_TEST_ID = /getByTestId\(\s*[`'"]([A-Za-z][\w:-]{2,})[`'"]/g;
+    const KEBAB = /[a-z][a-z0-9]*(?:-{1,2}[a-z0-9]+)+/g;
+    // BEM base whose modifier is composed DYNAMICALLY, so no concrete class literal exists
+    // in the diff to grep: `ads-button--${kind}`, "ads-button--" + kind, clsx(base && `x--${y}`).
+    // Match a kebab base + `--` followed by a NON-alphanumeric (interpolation `$`, quote,
+    // paren, whitespace) and capture the `<base>--` prefix. The page objects' concrete
+    // modifier classes (ads-button--primary, ads-button--secondary) all start with that
+    // prefix, so a substring match on it promotes them — the shared/design-system component
+    // case a static-literal scan (KEBAB) misses. (A STATIC modifier like `foo--bar` is left
+    // to KEBAB, which captures the whole class.)
+    const BEM_DYNAMIC = /([a-z][a-z0-9]*(?:-[a-z0-9]+)+--)(?![a-z0-9])/g;
+    for (const raw of fileDiff.split("\n")) {
+        if (!(raw.startsWith("+") || raw.startsWith("-")))
+            continue;
+        if (raw.startsWith("+++") || raw.startsWith("---"))
+            continue;
+        const line = raw.slice(1);
+        for (const re of [ATTR, GET_BY_TEST_ID]) {
+            re.lastIndex = 0;
+            let m;
+            while ((m = re.exec(line)) !== null) {
+                if (isDistinctiveSelector(m[1], true))
+                    out.add(m[1]);
+                if (out.size >= MAX_CHANGED_SELECTORS)
+                    return [...out];
+            }
+        }
+        KEBAB.lastIndex = 0;
+        let k;
+        while ((k = KEBAB.exec(line)) !== null) {
+            if (isDistinctiveSelector(k[0], false))
+                out.add(k[0]);
+            if (out.size >= MAX_CHANGED_SELECTORS)
+                return [...out];
+        }
+        BEM_DYNAMIC.lastIndex = 0;
+        let b;
+        while ((b = BEM_DYNAMIC.exec(line)) !== null) {
+            if (isDistinctiveSelector(b[1], false))
+                out.add(b[1]);
+            if (out.size >= MAX_CHANGED_SELECTORS)
+                return [...out];
+        }
+    }
+    return [...out];
+}

package/build/utils/frontendSelectors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/frontendSelectors.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "@jest/globals";
+import { extractChangedSelectors } from "./frontendSelectors.js";
+describe("extractChangedSelectors", () => {
+    it("captures both the old (removed) and new (added) value of a renamed data-testid", () => {
+        const diff = [
+            "@@ -175,7 +175,7 @@",
+            '-        dataTestId="confirmation-modal-confirm-button"',
+            '+        dataTestId="confirmation-modal-primary-button"',
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        // dataTestId isn't a data-* attribute, but both are distinctive kebab class-ish tokens
+        expect(sel).toEqual(expect.arrayContaining([
+            "confirmation-modal-confirm-button",
+            "confirmation-modal-primary-button",
+        ]));
+    });
+    it("captures data-testid attribute values", () => {
+        const diff = '+  <input data-testid="members-search-field" />\n-  <input data-testid="members-search-input" />';
+        const sel = extractChangedSelectors(diff);
+        expect(sel).toEqual(expect.arrayContaining(["members-search-field", "members-search-input"]));
+    });
+    it("captures CSS class rename with BEM `--` and multi-segment kebab", () => {
+        const diff = [
+            '-  <div className="t--table-filter-columns-dropdown">',
+            '+  <div className="t--tbl-filter-column-select">',
+            '+  <button className="ads-button--primary">',
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        expect(sel).toEqual(expect.arrayContaining([
+            "t--table-filter-columns-dropdown",
+            "t--tbl-filter-column-select",
+            "ads-button--primary",
+        ]));
+    });
+    it("captures the BEM base prefix of a dynamically-composed modifier class", () => {
+        const diff = [
+            "-        className={clsx(ButtonClassName, className)}",
+            "+        className={clsx(ButtonClassName, kind && `ads-button--${kind}`, className)}",
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        // no concrete `ads-button--primary` literal exists in the diff — capture the base prefix
+        expect(sel).toContain("ads-button--");
+    });
+    it("captures the BEM base from string-concatenation too, but leaves STATIC modifiers to the kebab pass", () => {
+        const concat = extractChangedSelectors('+  const cls = "ads-button--" + kind;');
+        expect(concat).toContain("ads-button--");
+        // a fully static modifier is captured whole (not as a bare `foo-bar--` prefix)
+        const staticMod = extractChangedSelectors('+  <div className="t--tbl-filter-column-select" />');
+        expect(staticMod).toContain("t--tbl-filter-column-select");
+        expect(staticMod).not.toContain("t--tbl-filter-column-select--");
+    });
+    it("captures getByTestId arguments", () => {
+        const diff = "+  const btn = page.getByTestId('workflow-settings-modal');";
+        expect(extractChangedSelectors(diff)).toContain("workflow-settings-modal");
+    });
+    it("drops single-hyphen styling utilities and short/generic tokens", () => {
+        const diff = [
+            '+  <div className="flex-start space-between text-align" />',
+            '+  const gap = "sans-serif";',
+        ].join("\n");
+        expect(extractChangedSelectors(diff)).toEqual([]);
+    });
+    it("drops multi-hyphen utility / design-token classes (numeric scale + utility roots)", () => {
+        const diff = [
+            '-  <div className="text-gray-500 bg-blue-600 flex-row-reverse" />',
+            '+  <div className="text-gray-600 bg-blue-700 grid-cols-3" />',
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        for (const util of ["text-gray-500", "text-gray-600", "bg-blue-600", "bg-blue-700", "flex-row-reverse", "grid-cols-3"]) {
+            expect(sel).not.toContain(util);
+        }
+    });
+    it("keeps semantic multi-hyphen identifiers and BEM classes (not utility)", () => {
+        const diff = [
+            '+  <div className="confirmation-modal-confirm-button user-profile-header" />',
+            '+  <div className="t--tbl-filter-column-select" />',
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        expect(sel).toEqual(expect.arrayContaining([
+            "confirmation-modal-confirm-button",
+            "user-profile-header",
+            "t--tbl-filter-column-select",
+        ]));
+    });
+    it("ignores context (unchanged) lines and file headers", () => {
+        const diff = [
+            "--- a/src/Component.tsx",
+            "+++ b/src/Component.tsx",
+            '   <div className="t--unchanged-context-selector" />', // context line (leading space)
+            '+  <div className="t--added-real-selector" />',
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        expect(sel).toContain("t--added-real-selector");
+        expect(sel).not.toContain("t--unchanged-context-selector");
+        expect(sel).not.toContain("Component"); // +++/--- headers ignored
+    });
+    it("does not leak a partial prefix from an interpolated template-literal attribute value", () => {
+        const diff = [
+            "+  <input data-testid={`members-search-${id}`} />",
+            "+  <button data-testid={`confirmation-modal-${kind}`} />",
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        expect(sel).not.toContain("members-search-");
+        expect(sel).not.toContain("confirmation-modal-");
+    });
+    it("does not capture non-literal expression attribute values (data-testid={someVar})", () => {
+        const diff = [
+            "+  <div data-testid={someVariableName} />",
+            "+  <div data-testid={'members-search-field'} />",
+        ].join("\n");
+        const sel = extractChangedSelectors(diff);
+        expect(sel).not.toContain("someVariableName"); // variable name, not a literal
+        expect(sel).toContain("members-search-field"); // quoted literal still captured
+    });
+    it("returns [] for an empty diff", () => {
+        expect(extractChangedSelectors("")).toEqual([]);
+    });
+});

package/build/utils/importerHop.d.ts

@@ -31,6 +31,14 @@ export declare function deriveResourceToken(file: string): string;
  * `[deriveResourceToken(file)]` (or `[]` if that's generic/unknown) —
  * identical to today's filename-only behavior.
  */
+/**
+ * Declared symbol names changed in a unified diff — from added-line declarations
+ * AND from the hunk-header enclosing type (so a field-only edit to an existing class,
+ * e.g. `DeploymentCreate.work_pool_name` → required, still yields `DeploymentCreate`).
+ * Returns raw names, used both for resource-token derivation (via `tokensFromSymbol`)
+ * and for content-grep matching against test bodies (SKYR-3924).
+ */
+export declare function extractChangedSymbols(diffHunk: string): string[];
 export declare function deriveResourceTokensForFile(file: string, diffHunk?: string): string[];
 /**
  * All singular resource tokens implied by an endpoint path, used for affinity
@@ -114,6 +122,16 @@ export declare function extractFieldNamesFromAddedLines(lines: string[]): string
  * without re-implementing the diff-header walk.
  */
 export declare function sliceAddedLinesByFile(diffContent: string): Map<string, string[]>;
+/**
+ * Splits a unified diff into per-file raw sections — every line after a file's
+ * `diff --git` header up to the next one — keyed by the `b/` (post-change) path.
+ * Unlike `sliceAddedLinesByFile` (added lines only), this preserves the `@@`
+ * hunk headers, so `extractChangedSymbols`' enclosing-type extraction (which
+ * reads `@@ ... class Foo`) still works when a single file's section is passed
+ * to `deriveResourceTokensForFile`. Use this for per-file token derivation that
+ * must not mix symbols across files in a multi-file diff (SKYR-3924).
+ */
+export declare function sliceDiffByFile(diffContent: string): Map<string, string>;
 /**
  * Computes added-field names per file for the given files, from a full
  * unified diff. Files with no added-line matches are omitted from the result