@skyramp/mcp 0.3.8 → 0.4.0-rc.1

package/build/utils/dartRouteExtractor.d.ts

@@ -1,45 +1,29 @@
 /**
- * Dart route extraction for Flutter apps using the `go_router` package.
+ * Routes a Flutter app declares with `go_router` — SKYR-4341.
  *
- * Walks the repo's Dart sources looking for GoRoute declarations with
- * string-literal `path:` arguments:
+ * Answers one question, the same one `sourceRouteExtractor` answers for the web:
+ * which URL renders which file. Restored from the version `d0982a04` deleted and
+ * narrowed to that question — the v1 reader also carried metadata for a caller
+ * that ranked pages and fell back to every renderable route, and that caller is
+ * gone.
  *
  *   GoRoute(path: '/login', builder: (ctx, st) => LoginScreen())
- *   GoRoute(path: "/profile/:id", builder: ...)
  *
- * Why regex (not a Dart compiler): Dart parsers (analyzer, dart-analyzer
- * package) require a Dart SDK install. Regex on the GoRoute string-literal-path
- * subset gives ~95% coverage of real customer apps with zero install cost.
- * Constants like `path: _kHome` are deliberately skipped — emitting them
- * as a URL `_kHome` would mislead the agent worse than dropping them.
- *
- * Each route also carries metadata to support diff-matching in the caller
- * (findCandidatePagesByDartRoute):
- *
- *   - `screenWidgets`: identifiers referenced as builder/pageBuilder targets,
- *     e.g. `AuthorsScreen`. Resolved through the file's imports to absolute
- *     paths in `screenFiles`.
- *   - `screenFiles`: the imported source files those identifiers come from.
- *   - `isRedirectOnly`: true if the GoRoute has `redirect:` but no
- *     `builder:` or `pageBuilder:` — these don't render UI, just redirect.
- *
- * Scope choices for slice 1:
- *   - GoRouter only (`MaterialApp.routes` and `auto_route` deferred)
- *   - String-literal `path:` only (no constant resolution)
- *   - Nested GoRoutes emit each declaration verbatim — the absolute parent
- *     plus relative children. Caller may compose them later.
+ * Regex rather than a Dart parser: every Dart parser needs a Dart SDK on the
+ * host. The string-literal `path:` subset covers the shapes real apps write at
+ * no install cost. A computed path (`path: _kHome`) is skipped rather than
+ * emitted as the literal `_kHome`, which would name a URL the app never serves.
  */
-/** A route declaration discovered in Dart source. */
+/** One route found in Dart source. Same shape as `SourceRoute`, so both readers
+ *  feed the route table the same way. */
 export interface DartRoute {
-    /** URL path string from the GoRoute(path: ...) declaration (verbatim). */
+    /** URL path from `GoRoute(path: ...)`, verbatim. */
     path: string;
-    /** Dart file the declaration was found in (absolute path). */
+    /** Widget the route builds, e.g. `LoginScreen`. */
+    componentName: string;
+    /** Absolute path of the file declaring that widget, when an import names it. */
+    componentFile?: string;
+    /** Absolute path of the file holding the declaration. */
     declaredIn: string;
-    /** Widget identifiers referenced from builder:/pageBuilder: (e.g. `AuthorsScreen`). */
-    screenWidgets: string[];
-    /** Resolved absolute paths for screenWidgets via the file's imports. */
-    screenFiles: string[];
-    /** True when GoRoute has `redirect:` but no `builder:`/`pageBuilder:` — no UI. */
-    isRedirectOnly: boolean;
 }
 export declare function extractDartRoutes(repositoryPath: string): DartRoute[];

package/build/utils/dartRouteExtractor.js

@@ -1,33 +1,18 @@
 /**
- * Dart route extraction for Flutter apps using the `go_router` package.
+ * Routes a Flutter app declares with `go_router` — SKYR-4341.
  *
- * Walks the repo's Dart sources looking for GoRoute declarations with
- * string-literal `path:` arguments:
+ * Answers one question, the same one `sourceRouteExtractor` answers for the web:
+ * which URL renders which file. Restored from the version `d0982a04` deleted and
+ * narrowed to that question — the v1 reader also carried metadata for a caller
+ * that ranked pages and fell back to every renderable route, and that caller is
+ * gone.
  *
  *   GoRoute(path: '/login', builder: (ctx, st) => LoginScreen())
- *   GoRoute(path: "/profile/:id", builder: ...)
  *
- * Why regex (not a Dart compiler): Dart parsers (analyzer, dart-analyzer
- * package) require a Dart SDK install. Regex on the GoRoute string-literal-path
- * subset gives ~95% coverage of real customer apps with zero install cost.
- * Constants like `path: _kHome` are deliberately skipped — emitting them
- * as a URL `_kHome` would mislead the agent worse than dropping them.
- *
- * Each route also carries metadata to support diff-matching in the caller
- * (findCandidatePagesByDartRoute):
- *
- *   - `screenWidgets`: identifiers referenced as builder/pageBuilder targets,
- *     e.g. `AuthorsScreen`. Resolved through the file's imports to absolute
- *     paths in `screenFiles`.
- *   - `screenFiles`: the imported source files those identifiers come from.
- *   - `isRedirectOnly`: true if the GoRoute has `redirect:` but no
- *     `builder:` or `pageBuilder:` — these don't render UI, just redirect.
- *
- * Scope choices for slice 1:
- *   - GoRouter only (`MaterialApp.routes` and `auto_route` deferred)
- *   - String-literal `path:` only (no constant resolution)
- *   - Nested GoRoutes emit each declaration verbatim — the absolute parent
- *     plus relative children. Caller may compose them later.
+ * Regex rather than a Dart parser: every Dart parser needs a Dart SDK on the
+ * host. The string-literal `path:` subset covers the shapes real apps write at
+ * no install cost. A computed path (`path: _kHome`) is skipped rather than
+ * emitted as the literal `_kHome`, which would name a URL the app never serves.
  */
 import * as fs from "fs";
 import * as path from "path";
@@ -35,35 +20,21 @@ import { collectFiles } from "./fileWalk.js";
 const MAX_CANDIDATE_FILES = 200;
 const MAX_WALK_DEPTH = 10;
 const SKIP_DIRS = new Set([
-    "build",
-    ".dart_tool",
-    ".git",
-    ".idea",
-    "android",
-    "ios",
-    "macos",
-    "linux",
-    "windows",
-    "web",
-    "node_modules",
-    "test",
-    ".pub-cache",
+    "build", ".dart_tool", ".git", ".idea", "android", "ios", "macos", "linux",
+    "windows", "web", "node_modules", "test", ".pub-cache",
 ]);
 /**
- * Match a GoRoute declaration's body — from the opening `(` through to its
- * matching `)`. We need the body to extract `path:`, screen widgets, and
- * the redirect/builder distinction.
- *
- * The regex captures the literal string after `path:` and the start of the
- * GoRoute call body; we then walk forward manually to find the matching
- * close paren (regex can't match balanced parens reliably).
+ * A `GoRoute(` through its `path:` string literal. The lazy `[\s\S]*?` scans
+ * forward for the first `path:`, so a GoRoute with no path of its own can borrow
+ * the next declaration's — those routes are dropped downstream instead, because
+ * a route with no resolvable widget produces no entry.
  */
 const GO_ROUTE_PATH_REGEX = /\bGoRoute\s*\(\s*(?:<[^>]+>\s*)?[\s\S]*?path\s*:\s*(['"])([^'"\\]*)\1/g;
-/** Identifier reference inside builder:/pageBuilder: bodies — `AuthorsScreen`, `Authors`. */
+/** An identifier used as a constructor inside a builder body. */
 const SCREEN_WIDGET_REGEX = /\b([A-Z][A-Za-z0-9_]*)\s*\(/g;
-/** Top-level Dart import: `import 'src/screens/authors.dart';` or `package:foo/bar.dart`. */
+/** A top-level Dart import. */
 const IMPORT_REGEX = /^\s*import\s+['"]([^'"]+)['"]/gm;
-/** Identifiers we never treat as screen widgets — Flutter framework + go_router internals. */
+/** Identifiers that are never a screen: Flutter and go_router internals. */
 const NON_SCREEN_IDENTIFIERS = new Set([
     "BuildContext", "GoRouterState", "GoRoute", "GoRouter", "ShellRoute",
     "StatefulShellRoute", "ShellRouteBase", "MaterialPage", "CupertinoPage",
@@ -72,54 +43,90 @@ const NON_SCREEN_IDENTIFIERS = new Set([
     "MaterialApp", "CupertinoApp", "Scaffold", "AppBar",
 ]);
 export function extractDartRoutes(repositoryPath) {
-    const candidates = findDartFiles(repositoryPath);
-    const seen = new Set();
     const routes = [];
-    for (const file of candidates) {
-        let source;
-        try {
-            source = fs.readFileSync(file, "utf-8");
+    const sources = new Map();
+    const read = (file) => {
+        if (!sources.has(file)) {
+            try {
+                sources.set(file, fs.readFileSync(file, "utf-8"));
+            }
+            catch {
+                sources.set(file, undefined);
+            }
         }
-        catch {
+        return sources.get(file);
+    };
+    for (const file of findDartFiles(repositoryPath)) {
+        const source = read(file);
+        if (!source)
             continue;
-        }
-        const imports = collectImports(source, file, repositoryPath);
+        const imports = dartImports(source, file, repositoryPath);
         GO_ROUTE_PATH_REGEX.lastIndex = 0;
         let match;
         while ((match = GO_ROUTE_PATH_REGEX.exec(source)) !== null) {
-            const pathValue = match[2];
-            if (seen.has(pathValue))
+            const routePath = match[2];
+            // A child route states its path relative to its parent. Composing the
+            // hierarchy is not done here, and emitting `details` as if it were a URL
+            // would send the browser to a page that does not exist.
+            if (!routePath.startsWith("/"))
                 continue;
-            seen.add(pathValue);
             const body = extractGoRouteBody(source, match.index);
-            const inspect = inspectGoRouteBody(body);
-            const screenFiles = [];
-            for (const widget of inspect.screenWidgets) {
-                const resolved = imports.get(widget);
-                if (resolved)
-                    screenFiles.push(resolved);
+            for (const componentName of screenWidgetsOf(body)) {
+                routes.push({
+                    path: routePath,
+                    componentName,
+                    componentFile: declaringFile(componentName, imports, read),
+                    declaredIn: file,
+                });
             }
-            routes.push({
-                path: pathValue,
-                declaredIn: file,
-                screenWidgets: inspect.screenWidgets,
-                screenFiles,
-                isRedirectOnly: inspect.isRedirectOnly,
-            });
         }
     }
     return routes;
 }
 /**
- * Starting at `start` (the index of the matched `GoRoute` token), find the
- * end of the GoRoute call by counting balanced `(` / `)`. Stops at the
- * matching close paren of the outermost GoRoute(...). Strings are skipped
- * so we don't mis-count a `)` inside a string literal.
- *
- * Returns the call body (between the outer parens) — empty string on failure.
+ * The file that declares `widget`, found by reading the importing file's own
+ * imports for the class. The v1 reader guessed instead — it derived candidate
+ * identifiers from each import's filename (`authors.dart` was assumed to export
+ * `Authors`, `AuthorsScreen`, `AuthorsPage`, `AuthorsView`) and accepted the
+ * first. A guess that lands wrong names a URL the file does not render, which is
+ * the one answer this scan must never give.
+ */
+function declaringFile(widget, imports, read) {
+    const declaration = new RegExp(`\\bclass\\s+${widget}\\b`);
+    for (const imported of imports) {
+        const source = read(imported);
+        if (source && declaration.test(source))
+            return imported;
+    }
+    return undefined;
+}
+/** Absolute paths of the repository files a Dart file imports. `package:` and
+ *  `dart:` imports are not resolved, so a widget reached only that way has no
+ *  file and its route is dropped rather than guessed. */
+function dartImports(source, filePath, repositoryPath) {
+    const resolved = [];
+    const fileDir = path.dirname(filePath);
+    IMPORT_REGEX.lastIndex = 0;
+    let match;
+    while ((match = IMPORT_REGEX.exec(source)) !== null) {
+        const spec = match[1];
+        if (spec.startsWith("package:") || spec.startsWith("dart:"))
+            continue;
+        if (!spec.endsWith(".dart"))
+            continue;
+        const target = path.resolve(fileDir, spec);
+        if (!target.startsWith(repositoryPath))
+            continue;
+        if (!resolved.includes(target))
+            resolved.push(target);
+    }
+    return resolved;
+}
+/**
+ * The GoRoute call body, from the `(` after `GoRoute` to its matching `)`.
+ * String contents are skipped so a `)` inside a literal does not close the call.
  */
 function extractGoRouteBody(source, start) {
-    // Find the first '(' after `GoRoute`
     const openParen = source.indexOf("(", start);
     if (openParen < 0)
         return "";
@@ -150,49 +157,32 @@ function extractGoRouteBody(source, start) {
         return "";
     return source.slice(openParen + 1, i - 1);
 }
-/**
- * Inspect a GoRoute body to find:
- *   - screen widget identifiers from builder:/pageBuilder:
- *   - whether the route is redirect-only (no builder/pageBuilder)
- *
- * The `routes:` nested GoRoute siblings are stripped before scanning so
- * we don't pick up child route widgets as part of the parent's screens.
- */
-function inspectGoRouteBody(body) {
-    const builderPart = extractKeyValue(body, "builder");
-    const pageBuilderPart = extractKeyValue(body, "pageBuilder");
-    const redirectPart = extractKeyValue(body, "redirect");
-    const screenWidgets = [];
-    for (const part of [builderPart, pageBuilderPart]) {
+/** Widgets a GoRoute body builds. A route with `redirect:` and no builder
+ *  renders nothing, and yields none. */
+function screenWidgetsOf(body) {
+    const widgets = [];
+    for (const key of ["builder", "pageBuilder"]) {
+        const part = keyValueOf(body, key);
         if (!part)
             continue;
         SCREEN_WIDGET_REGEX.lastIndex = 0;
         let m;
         while ((m = SCREEN_WIDGET_REGEX.exec(part)) !== null) {
-            const id = m[1];
-            if (NON_SCREEN_IDENTIFIERS.has(id))
+            if (NON_SCREEN_IDENTIFIERS.has(m[1]))
                 continue;
-            if (!screenWidgets.includes(id))
-                screenWidgets.push(id);
+            if (!widgets.includes(m[1]))
+                widgets.push(m[1]);
         }
     }
-    const hasBuilder = !!builderPart || !!pageBuilderPart;
-    const hasRedirect = !!redirectPart;
-    const isRedirectOnly = hasRedirect && !hasBuilder;
-    return { screenWidgets, isRedirectOnly };
+    return widgets;
 }
-/**
- * Find a `key:` value in a GoRoute body. Returns the substring after `key:`
- * up to the next top-level comma (depth 0 brace/paren/bracket), or `null`
- * when the key isn't present. Strings and nested groups are skipped.
- */
-function extractKeyValue(body, key) {
+/** The value of `key:` in a GoRoute body, up to the next top-level comma. */
+function keyValueOf(body, key) {
     const re = new RegExp(`\\b${key}\\s*:`, "g");
     const m = re.exec(body);
     if (!m)
         return null;
     let i = m.index + m[0].length;
-    // Skip whitespace
     while (i < body.length && /\s/.test(body[i]))
         i++;
     const start = i;
@@ -225,70 +215,8 @@ function extractKeyValue(body, key) {
     }
     return body.slice(start, i).trim();
 }
-/**
- * Build a `local-name → absolute-file-path` map from the file's imports.
- *
- * Dart imports two ways:
- *   import 'src/screens/authors.dart';   → relative within current package
- *   import 'package:foo/screens/x.dart'; → cross-package, not resolved here
- *
- * We only resolve relative imports (the common case for in-app screens).
- * The "local name" for a relative import is taken as ALL identifiers that
- * the file exports — but since we don't parse the imported file's exports,
- * we use a coarse approximation: the importing file's `import 'X.dart';`
- * makes available any PascalCase identifier referenced from the file's
- * scope. We map every identifier we see in builder/pageBuilder bodies to
- * the union of relative imports — first matching one wins.
- *
- * For the common Flutter pattern (one screen widget per screen file with
- * a matching name like `AuthorsScreen`), we approximate via filename:
- *   import 'src/screens/authors.dart' → expose `AuthorsScreen`, `Authors`
- *
- * False positives on this approximation just mean we surface a route that
- * shouldn't have been; false negatives just mean we fall back to "no
- * diff-match" and surface all routes (the previous behavior).
- */
-function collectImports(source, filePath, repoPath) {
-    const result = new Map();
-    const fileDir = path.dirname(filePath);
-    IMPORT_REGEX.lastIndex = 0;
-    let match;
-    while ((match = IMPORT_REGEX.exec(source)) !== null) {
-        const spec = match[1];
-        if (spec.startsWith("package:") || spec.startsWith("dart:"))
-            continue;
-        if (!spec.endsWith(".dart"))
-            continue;
-        const resolved = path.resolve(fileDir, spec);
-        if (!resolved.startsWith(repoPath))
-            continue;
-        // Filename-based heuristic: `authors.dart` exposes `Authors`, `AuthorsScreen`,
-        // `AuthorsScreenState`, etc. We register a few common shapes derived from
-        // the file's basename. Conflicts (the same identifier present in two
-        // imports) resolve to the first registration.
-        const base = path.basename(spec, ".dart");
-        const camel = snakeToCamel(base);
-        const candidates = [
-            camel,
-            camel + "Screen",
-            camel + "Page",
-            camel + "View",
-        ];
-        for (const id of candidates) {
-            if (!result.has(id))
-                result.set(id, resolved);
-        }
-    }
-    return result;
-}
-function snakeToCamel(s) {
-    return s
-        .split("_")
-        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-        .join("");
-}
-function findDartFiles(repoPath) {
-    return collectFiles(repoPath, {
+function findDartFiles(repositoryPath) {
+    return collectFiles(repositoryPath, {
         match: (entry) => entry.name.endsWith(".dart"),
         limit: MAX_CANDIDATE_FILES,
         maxDepth: MAX_WALK_DEPTH,

package/build/utils/featureFlags.d.ts

@@ -97,3 +97,15 @@ export declare function isPomReuseEnabled(): boolean;
  * yields the single reuse pass it did before the feature existed.
  */
 export declare function isUtilsReuseEnabled(): boolean;
+/**
+ * Returns true when the calling agent has the Skyramp Agent Skills plugin
+ * loaded (SKYRAMP_SKILLS_LOADED=1). Testbot sets this only for Claude Code
+ * runs that also pass `--plugin-dir` at the `plugin/` directory of this
+ * package (SKYR-4296).
+ *
+ * When ON, tools whose only job is to hand back instruction text that now
+ * lives in a skill are not registered, and the prompts that used to name
+ * those tools name the skill instead. Two entry points for one text would let
+ * the tool result override the prompt on conflict.
+ */
+export declare function isSkillsLoaded(): boolean;

package/build/utils/featureFlags.js

@@ -129,3 +129,17 @@ function isUtilsReuseDefaultOrg() {
         "";
     return UTILS_REUSE_DEFAULT_ORGS.includes(owner.toLowerCase());
 }
+/**
+ * Returns true when the calling agent has the Skyramp Agent Skills plugin
+ * loaded (SKYRAMP_SKILLS_LOADED=1). Testbot sets this only for Claude Code
+ * runs that also pass `--plugin-dir` at the `plugin/` directory of this
+ * package (SKYR-4296).
+ *
+ * When ON, tools whose only job is to hand back instruction text that now
+ * lives in a skill are not registered, and the prompts that used to name
+ * those tools name the skill instead. Two entry points for one text would let
+ * the tool result override the prompt on conflict.
+ */
+export function isSkillsLoaded() {
+    return process.env.SKYRAMP_SKILLS_LOADED === "1";
+}

package/build/utils/frontendSelectors.d.ts

@@ -1,34 +1,55 @@
 /**
- * Frontend selector extraction for UI-test-maintenance discovery (Pass 3, "selector-edge").
+ * The `data-*` attributes and selector literals a frontend diff touched.
  *
- * 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.
+ * One reader now: the removal guard (SKYR-4305), which reports an element the
+ * diff deleted from a page that survives so the agent can assert it is gone.
  *
- * 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.
+ * This module also used to lift every selector literal a diff added or removed,
+ * so discovery could promote a page object whose body referenced one. That was
+ * the server deciding which existing tests a change touches — the external
+ * tests are loaded uncut up to the discovery cap now, and the agent reads them.
  */
-export declare const MAX_CHANGED_SELECTORS = 80;
+/** A removed element's identity: the `data-*` attribute and its literal value. */
+export interface RemovedAttribute {
+    /** Lower-cased attribute name, e.g. `data-testid`, `data-cy`, `data-section`. */
+    attribute: string;
+    value: string;
+}
+/** Identifying attribute VALUES that appear on `+` lines of a diff (any number of files). */
+export declare function extractAddedAttributeValues(diff: string): string[];
 /**
- * Extract selector literals added or removed in a single file's diff slice.
+ * Identifying `data-*` attributes one file's diff REMOVED: literals on `-` lines, minus the
+ * cases where the element still renders somewhere:
+ *
+ *   - **moved / extracted** — the same value appears on a `+` line of this file or, via
+ *     `addedValuesElsewhere`, anywhere else in the diff (a component extracted into a new
+ *     file is the common shape);
+ *   - **not an element** — a `-` line counts only when it opens a JSX/HTML tag or is a
+ *     wrapped attribute line of a tag opened above it, on a changed or an unchanged
+ *     line (the tag is carried until the `>` that closes it; a `>` inside a quoted
+ *     value, a `{…}` expression or an `=>` arrow is content and does not close it). A deleted comment, docs snippet, story arg or page-object
+ *     `getByTestId(...)` call that merely mentions the attribute is not an element
+ *     removal — the element itself may well survive on an unchanged context line;
+ *   - **renamed** — a rename cannot be told apart by literal identity (old and new
+ *     value differ by definition), so it is paired structurally: within the same hunk,
+ *     each removed ELEMENT is paired with AT MOST ONE added element that opens the same
+ *     tag, carries a NEW identifying attribute, and keeps every other attribute NAME
+ *     the removed element set on its changed lines (a rename may add attributes or
+ *     edit their values, never drop one). With the tag kept on a context line, the
+ *     changed lines are exactly the attributes that differ, so an in-place rename
+ *     compares only what it touched while an in-place replacement that drops the old
+ *     element's handlers does not pair. An element whose changed lines carry nothing
+ *     but the identifier pairs by tag alone: a relabelled rename (`clear-state` →
+ *     `reset-session`, "Clear State" → "Reset Session") and a same-shape replacement
+ *     are the same diff, and the tie goes to rename — a guard on a retired identifier
+ *     passes vacuously, and the agent still reads the diff for what the list lacks. A paired added element is consumed, so one addition
+ *     suppresses one removal, not every removal in the hunk. SKYR-4339: pairing by tag
+ *     alone consumed a genuinely removed `<a href="#">` with a genuinely added
+ *     `<a href="https://…">` in the same hunk (judgement eval RG03), so the guard was
+ *     never listed.
  *
- * 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`).
+ * Feeds `uiContext.removedElements` (SKYR-4305) — the grounding for a removal guard
+ * (`toBeHidden()` on `getByTestId(value)` for `data-testid`, on
+ * `locator('[<attribute>="<value>"]')` for any other `data-*`).
  */
-export declare function extractChangedSelectors(fileDiff: string): string[];
+export declare function extractRemovedAttributes(fileDiff: string, addedValuesElsewhere?: Iterable<string>): RemovedAttribute[];