@skyramp/mcp 0.4.1 → 0.4.2-rc.1

package/build/utils/reportVerification.js

@@ -5,7 +5,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { testFileMatches } from "./utils.js";
 import { DriftAction } from "../types/TestAnalysis.js";
-import { baselineFileMatchesStem, baselineStem } from "./rebaselineSnapshots.js";
+import { baselineFileMatchesStem, baselineStem, } from "./rebaselineSnapshots.js";
 const execFileAsync = promisify(execFile);
 /**
  * Enumerate every path that differs from HEAD in the working tree — staged,
@@ -122,11 +122,13 @@ export async function listChangedFiles(repoRoot) {
  *  - DELETE verdicts — applied deterministically by the delivery step, not
  *    necessarily reflected in the tree at report time.
  *  - IGNORE / VERIFY verdicts — assert that NO edit was needed.
- *  - Claims for files outside this checkout (cross-repo `repository`, or an
- *    absolute path resolving outside `repoRoot`) — a different checkout owns them.
+ *  - Claims for files outside this checkout (a `repository` naming another
+ *    checkout THIS RUN ANALYZED, or an absolute path resolving outside
+ *    `repoRoot`) — a different checkout owns them. A name the run does not know
+ *    owns nothing, so it is reported rather than exempted.
  */
 export function findUnchangedFileClaims(input) {
-    const { repoRoot, changedFiles, newTests, verdicts, primaryRepository, planOnly, } = input;
+    const { repoRoot, changedFiles, newTests, verdicts, primaryRepository, knownRepositories, planOnly, } = input;
     const unbacked = [];
     const isBacked = (claimedPath) => {
         let candidate = claimedPath;
@@ -182,12 +184,14 @@ export function findUnchangedFileClaims(input) {
         if (!t.fileName)
             continue;
         // Cross-repo finding — its file lives in a different checkout, not this tree.
-        // Exempt any claim explicitly attributed to a repo that isn't the primary.
-        // When the primary repo is unknown (primaryRepository undefined) we can't
-        // confirm the file belongs to this checkout, so any explicitly-attributed
-        // claim is exempted rather than risk a false rejection.
-        if (t.repository && t.repository !== primaryRepository)
+        // Exempt it only when the run actually analyzed that checkout: any other name
+        // points at no tree, and waving it through is how an uncreated test ships.
+        if (t.repository !== primaryRepository) {
+            if (knownRepositories.includes(t.repository))
+                continue;
+            unbacked.push(`newTestsCreated "${t.testId ?? t.fileName}" names repository "${t.repository}", which this run did not analyze (it analyzed ${knownRepositories.join(", ")})`);
             continue;
+        }
         if (!isBacked(t.fileName)) {
             unbacked.push(`newTestsCreated "${t.testId ?? t.fileName}" claims file "${t.fileName}", but no matching file was created or modified in the working tree`);
         }
@@ -395,7 +399,7 @@ export async function findInvalidSourceCitations(input) {
             entry: `issuesFound[${i}]`,
             cited,
             symbol,
-            declared: input.issues[i].repository?.trim(),
+            declared: input.issues[i].repository,
             resolved: resolved.map((hit) => hit.checkout),
         });
         if (attribution.message)
@@ -408,9 +412,7 @@ export async function findInvalidSourceCitations(input) {
  *  A checkout the run could not name contributes nothing: it can be neither
  *  stamped nor offered as a candidate. */
 function namesOf(resolved) {
-    return [
-        ...new Set(resolved.map((c) => c.repository).filter((r) => !!r)),
-    ];
+    return [...new Set(resolved.map((c) => c.repository))];
 }
 /**
  * Reconcile where a citation resolved with what the entry says about it, giving
@@ -425,7 +427,7 @@ function attributeCitation(args) {
         // owner/repo is case-insensitive on GitHub, so a differently-cased attribution
         // is the same repo — accepted, and re-stamped in the run's own spelling rather
         // than sent back for a rewrite that would change nothing.
-        const match = resolved.find((c) => c.repository && c.repository.toLowerCase() === declared.toLowerCase());
+        const match = resolved.find((c) => c.repository.toLowerCase() === declared.toLowerCase());
         if (match)
             return match.repository === declared
                 ? {}
@@ -449,10 +451,8 @@ function attributeCitation(args) {
         }
         return {}; // Cannot name the alternatives — accept, and stamp nothing.
     }
-    // Exactly one checkout. Stamp it unless it is the primary, whose findings are
-    // identified downstream by having NO repository — see SourceCitationCheck.
+    // Exactly one checkout. Stamp it, the primary included: an item names its repo
+    // whichever checkout it came from, so absence no longer means "the primary".
     const [only] = resolved;
-    return only.primary || !only.repository
-        ? {}
-        : { repository: only.repository };
+    return { repository: only.repository };
 }

package/build/utils/repositorySlug.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `owner/repo` from a git remote URL. Accepts the two spellings a checkout's
+ * `origin` carries — ssh (`git@host:owner/repo.git`) and https
+ * (`https://host/owner/repo`) — with or without the `.git` suffix.
+ *
+ * Returns undefined when the URL yields no owner/repo pair, which the callers
+ * treat differently: see `repositorySlugOf` and `tryRepositorySlug` below.
+ */
+export declare function parseOwnerRepo(remoteUrl: string): string | undefined;
+/**
+ * `owner/repo` of the checkout at `dir`, or undefined when it is not a git repo,
+ * has no `origin` remote, or the remote URL names no owner/repo pair.
+ *
+ * For a caller that cannot proceed without the name, use `repositorySlugOf`.
+ */
+export declare function tryRepositorySlug(dir: string): Promise<string | undefined>;
+/**
+ * `owner/repo` of the checkout at `dir`. Throws, naming the path, when the
+ * directory cannot name one: every repository attribution in a run comes from
+ * here, so a missing name is a run that cannot attribute anything rather than
+ * one that attributes it to a guess.
+ */
+export declare function repositorySlugOf(dir: string): Promise<string>;
+/** Test seam: drop the memoized lookups so a fixture can rebuild a checkout. */
+export declare function clearRepositorySlugCache(): void;
+/**
+ * A checkout path in the spelling two calls can be compared in: symlinks
+ * resolved, relative spellings absolute. Falls back to the absolute path when
+ * the directory does not exist, so a caller comparing paths still gets an
+ * answer rather than an error about a path it only means to name.
+ */
+export declare function resolveRealPath(dir: string): Promise<string>;

package/build/utils/repositorySlug.js

@@ -0,0 +1,77 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import fs from "fs/promises";
+import path from "path";
+const execFileAsync = promisify(execFile);
+/**
+ * `owner/repo` from a git remote URL. Accepts the two spellings a checkout's
+ * `origin` carries — ssh (`git@host:owner/repo.git`) and https
+ * (`https://host/owner/repo`) — with or without the `.git` suffix.
+ *
+ * Returns undefined when the URL yields no owner/repo pair, which the callers
+ * treat differently: see `repositorySlugOf` and `tryRepositorySlug` below.
+ */
+export function parseOwnerRepo(remoteUrl) {
+    const match = remoteUrl.trim().match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+    if (!match)
+        return undefined;
+    const [, owner, repo] = match;
+    return `${owner}/${repo}`;
+}
+// One `git remote get-url` per directory for the life of the process. The
+// value is the resolved slug, or undefined when the directory cannot name one.
+const slugCache = new Map();
+/**
+ * `owner/repo` of the checkout at `dir`, or undefined when it is not a git repo,
+ * has no `origin` remote, or the remote URL names no owner/repo pair.
+ *
+ * For a caller that cannot proceed without the name, use `repositorySlugOf`.
+ */
+export function tryRepositorySlug(dir) {
+    const cached = slugCache.get(dir);
+    if (cached)
+        return cached;
+    const lookup = (async () => {
+        try {
+            const { stdout } = await execFileAsync("git", ["-C", dir, "remote", "get-url", "origin"], { timeout: 5_000 });
+            return parseOwnerRepo(stdout);
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    slugCache.set(dir, lookup);
+    return lookup;
+}
+/**
+ * `owner/repo` of the checkout at `dir`. Throws, naming the path, when the
+ * directory cannot name one: every repository attribution in a run comes from
+ * here, so a missing name is a run that cannot attribute anything rather than
+ * one that attributes it to a guess.
+ */
+export async function repositorySlugOf(dir) {
+    const slug = await tryRepositorySlug(dir);
+    if (!slug) {
+        throw new Error(`cannot read owner/repo from the origin remote of ${dir}: the checkout has no origin, or its URL names no owner/repo`);
+    }
+    return slug;
+}
+/** Test seam: drop the memoized lookups so a fixture can rebuild a checkout. */
+export function clearRepositorySlugCache() {
+    slugCache.clear();
+}
+/**
+ * A checkout path in the spelling two calls can be compared in: symlinks
+ * resolved, relative spellings absolute. Falls back to the absolute path when
+ * the directory does not exist, so a caller comparing paths still gets an
+ * answer rather than an error about a path it only means to name.
+ */
+export async function resolveRealPath(dir) {
+    const absolute = path.resolve(dir);
+    try {
+        return await fs.realpath(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}

package/build/utils/reuseRouting.js

@@ -14,8 +14,12 @@ export function isBrowserTestType(testType) {
 // skyramp_modularization runs BEFORE skyramp_reuse_code and the reuse pass seeds
 // the shared utils file from the helpers it created. The utils flag is the
 // single gate for every test type — the modularization prompts' per-step
-// extraction reads the same predicate, so the hand-off, the extraction and the
-// seeding step agree on every codeReuse flow. Integration qualifies whenever the flag is on;
+// extraction reads this predicate, so the extraction and the seeding step agree
+// on every codeReuse flow. The two hand-off sites (generation and the
+// maintenance step) read isModularizeFirstHandOffTarget in prompts/reuse-hand-off.ts,
+// which is THIS predicate plus a utils spec for the language: a language the
+// verifier does not cover has no payable reuse half, so no hand-off is owed for
+// it. Integration qualifies whenever the flag is on;
 // UI only while the POM path is off (POM refactoring supersedes modularization,
 // and the testbot UI flow asks for codeReuse unconditionally, so the flag is what
 // keeps the default-off behavior a no-op reuse pass). e2e and load are not

package/build/utils/runSerialized.d.ts

@@ -0,0 +1,3 @@
+export declare function runSerialized<T>(key: string, fn: () => Promise<T>): Promise<T>;
+/** Test seam: how many keys currently have work queued or running. */
+export declare function pendingSerializedKeys(): number;

package/build/utils/runSerialized.js

@@ -0,0 +1,39 @@
+/**
+ * Run async work one at a time per key, in arrival order, within this process.
+ *
+ * A caller that must read some state, act, and write the state back cannot be
+ * interleaved with another caller on the same key without both reading the
+ * same starting state. Callers on different keys never wait for each other.
+ * A rejected run releases the key like a resolved one.
+ *
+ * Re-entrant: work that already holds a key (it is running inside a
+ * runSerialized on that key, however deep) runs immediately instead of
+ * queueing behind itself — otherwise a helper that serializes on the state
+ * file, called from a handler that already serializes on it, would wait for
+ * its own caller to finish and deadlock.
+ */
+import { AsyncLocalStorage } from "async_hooks";
+const tails = new Map();
+const held = new AsyncLocalStorage();
+export async function runSerialized(key, fn) {
+    const holding = held.getStore() ?? new Set();
+    if (holding.has(key))
+        return fn();
+    const previous = tails.get(key) ?? Promise.resolve();
+    const run = previous.then(() => held.run(new Set([...holding, key]), fn));
+    // What the next caller waits on: settled either way, so one failure does not
+    // wedge the key.
+    const tail = run.then(() => undefined, () => undefined);
+    tails.set(key, tail);
+    try {
+        return await run;
+    }
+    finally {
+        if (tails.get(key) === tail)
+            tails.delete(key);
+    }
+}
+/** Test seam: how many keys currently have work queued or running. */
+export function pendingSerializedKeys() {
+    return tails.size;
+}

package/build/utils/screenRoutes.js

@@ -39,7 +39,16 @@ import { extractSourceRoutes } from "./sourceRouteExtractor.js";
 /** Files that can import, and therefore render, a frontend module. */
 const FRONTEND_SOURCE_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|vue|svelte|dart)$/i;
 const SKIP_DIRS = new Set([
-    "node_modules", ".git", "dist", "build", "out", ".next", ".nuxt", ".svelte-kit", "coverage", "vendor",
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    "coverage",
+    "vendor",
 ]);
 /** Walk cap. Hitting it means the index is incomplete, and an incomplete index
  *  cannot honestly say "nothing mounts this" — the whole repository answers
@@ -65,7 +74,9 @@ function toPosix(value) {
     return value.replace(/\\/g, "/");
 }
 function stripExtension(file) {
-    return /\.d\.ts$/i.test(file) ? file.slice(0, -5) : file.slice(0, file.length - path.posix.extname(file).length);
+    return /\.d\.ts$/i.test(file)
+        ? file.slice(0, -5)
+        : file.slice(0, file.length - path.posix.extname(file).length);
 }
 /** The strings an import specifier can use to name this file: the file itself, the
  *  file without its extension, and for an `index.*` module its directory. */
@@ -94,7 +105,9 @@ function normalizeRelative(relativePath) {
  *  and this index is keyed by the stem instead because the specifier is already
  *  isolated by the time we get here. */
 function stemKeys(file) {
-    return [...new Set(buildPathSignatures(file).map((signature) => signature.slice(0, -1)))];
+    return [
+        ...new Set(buildPathSignatures(file).map((signature) => signature.slice(0, -1))),
+    ];
 }
 /**
  * The candidate repository paths an import specifier could name.
@@ -125,8 +138,11 @@ function specifierCandidates(spec) {
     if (segments.length === 1)
         return { relative: false, paths: [] };
     const paths = [clean];
-    const scopedPackageShape = segments[0].length > 1 && segments[0].startsWith("@") && segments.length < 3;
-    if (!scopedPackageShape && (/^[@~#]/.test(segments[0]) || segments[0] === "src")) {
+    const scopedPackageShape = segments[0].length > 1 &&
+        segments[0].startsWith("@") &&
+        segments.length < 3;
+    if (!scopedPackageShape &&
+        (/^[@~#]/.test(segments[0]) || segments[0] === "src")) {
         paths.push(segments.slice(1).join("/"));
     }
     return { relative: false, paths };
@@ -217,7 +233,11 @@ function readTanStackRouteTree(repositoryPath, treeFile, filesByStem) {
         }
         const preLoader = /^\s*preLoaderRoute:\s*typeof\s+(\w+)/.exec(line);
         if (preLoader && pendingId !== undefined && pendingFullPath !== undefined) {
-            blocks.push({ id: pendingId, fullPath: pendingFullPath, ident: preLoader[1] });
+            blocks.push({
+                id: pendingId,
+                fullPath: pendingFullPath,
+                ident: preLoader[1],
+            });
             pendingId = undefined;
             pendingFullPath = undefined;
         }
@@ -316,7 +336,9 @@ function flutterPackages(repositoryPath) {
     for (const parent of PUBSPEC_MONOREPO_PARENTS) {
         let entries;
         try {
-            entries = fs.readdirSync(path.join(repositoryPath, parent), { withFileTypes: true });
+            entries = fs.readdirSync(path.join(repositoryPath, parent), {
+                withFileTypes: true,
+            });
         }
         catch {
             continue;
@@ -360,7 +382,9 @@ function dartPackagePath(spec, packages) {
 export function frameworkRouteFor(relativePath, framework) {
     // Next.js and Nuxt accept their routing directory at the root or under `src/`,
     // and neither spelling appears in the URL.
-    const below = relativePath.startsWith("src/") ? relativePath.slice(4) : relativePath;
+    const below = relativePath.startsWith("src/")
+        ? relativePath.slice(4)
+        : relativePath;
     switch (framework) {
         case "next":
             return nextRoute(below);
@@ -381,7 +405,9 @@ function bracketParam(segment) {
 /** Segments the Next app router organises the tree with and leaves out of the
  *  URL: route groups `(shop)`, private folders `_internal`, slots `@modal`. */
 function isNextAppOrganisingSegment(segment) {
-    return /^\(.+\)$/.test(segment) || segment.startsWith("_") || segment.startsWith("@");
+    return (/^\(.+\)$/.test(segment) ||
+        segment.startsWith("_") ||
+        segment.startsWith("@"));
 }
 function nextRoute(below) {
     const app = /^app\/(.*)$/.exec(below);
@@ -394,7 +420,11 @@ function nextRoute(below) {
         // `template`, `loading`, `error` and `not-found` wrap a page without being one.
         if (segments.pop() !== "page")
             return undefined;
-        return "/" + segments.filter((s) => !isNextAppOrganisingSegment(s)).map(bracketParam).join("/");
+        return ("/" +
+            segments
+                .filter((s) => !isNextAppOrganisingSegment(s))
+                .map(bracketParam)
+                .join("/"));
     }
     const pages = /^pages\/(.*)$/.exec(below);
     if (!pages)
@@ -411,14 +441,22 @@ function nextRoute(below) {
         return undefined;
     // No route groups in this router — `(shop)` is a literal directory name.
     const segments = stem.replace(/(?:^|\/)index$/, "").split("/");
-    return "/" + segments.filter((s) => s !== "").map(bracketParam).join("/");
+    return ("/" +
+        segments
+            .filter((s) => s !== "")
+            .map(bracketParam)
+            .join("/"));
 }
 function nuxtRoute(below) {
     const pages = /^pages\/(.*)\.vue$/.exec(below);
     if (!pages)
         return undefined;
     const segments = pages[1].replace(/(?:^|\/)index$/, "").split("/");
-    return "/" + segments.filter((s) => s !== "").map(nuxtParam).join("/");
+    return ("/" +
+        segments
+            .filter((s) => s !== "")
+            .map(nuxtParam)
+            .join("/"));
 }
 /** Nuxt 3 spells a parameter `[id]`, Nuxt 2 spells it `_id`. The underscore names
  *  one only as the WHOLE segment: a blanket rule made `order_total` `/order:total`. */
@@ -438,7 +476,11 @@ function svelteKitRoute(below) {
     if (segments.pop() !== "+page.svelte")
         return undefined;
     // The one non-Next framework with route groups, spelled the same way.
-    return "/" + segments.filter((s) => !/^\(.+\)$/.test(s)).map(svelteParam).join("/");
+    return ("/" +
+        segments
+            .filter((s) => !/^\(.+\)$/.test(s))
+            .map(svelteParam)
+            .join("/"));
 }
 /** SvelteKit adds an optional parameter, `[[lang]]`, to the bracket spellings. */
 function svelteParam(segment) {
@@ -476,7 +518,9 @@ function fileSystemRouteEntries(files) {
  *  through the stem index first: the route tree names hundreds of entry files, and
  *  comparing each against every file in the repository is quadratic. */
 function resolveWithin(dir, spec, filesByStem) {
-    const base = spec.startsWith(".") ? path.posix.normalize(path.posix.join(dir, spec)) : spec;
+    const base = spec.startsWith(".")
+        ? path.posix.normalize(path.posix.join(dir, spec))
+        : spec;
     const lastSegment = base.split("/").pop();
     if (!lastSegment)
         return undefined;
@@ -515,7 +559,9 @@ function collectRouteEntries(repositoryPath, files, fileSet, filesByStem, packag
     }
     if (packages.size > 0) {
         for (const route of extractDartRoutes(repositoryPath)) {
-            const relative = route.componentFile ? toPosix(path.relative(repositoryPath, route.componentFile)) : undefined;
+            const relative = route.componentFile
+                ? toPosix(path.relative(repositoryPath, route.componentFile))
+                : undefined;
             // A widget this reader could not trace to a file leaves the table short of
             // a route, the same way an unresolved web component does.
             if (relative && fileSet.has(relative))
@@ -533,7 +579,9 @@ function collectRouteEntries(repositoryPath, files, fileSet, filesByStem, packag
     for (const route of extractSourceRoutes(repositoryPath)) {
         if (!route.path)
             continue;
-        const relative = route.componentFile ? toPosix(path.relative(repositoryPath, route.componentFile)) : undefined;
+        const relative = route.componentFile
+            ? toPosix(path.relative(repositoryPath, route.componentFile))
+            : undefined;
         if (relative && fileSet.has(relative)) {
             entries.push({ pattern: route.path, entryFile: relative });
             continue;
@@ -601,7 +649,13 @@ function buildIndex(repositoryPath) {
             }
         }
     }
-    return { fileSet, importers, patternsByEntry, tableComplete: table.complete, importsComplete };
+    return {
+        fileSet,
+        importers,
+        patternsByEntry,
+        tableComplete: table.complete,
+        importsComplete,
+    };
 }
 // ── Query ───────────────────────────────────────────────────────────────────
 function candidatesFor(index, file) {
@@ -708,7 +762,9 @@ export function createScreenRouteLookup(repositoryPath) {
 /** The routes for a file, without the evidence. */
 export function createScreenRouteResolver(repositoryPath) {
     const lookup = createScreenRouteLookup(repositoryPath);
-    return (relativePath) => lookup.candidatesFor(relativePath)?.map((candidate) => candidate.routePattern);
+    return (relativePath) => lookup
+        .candidatesFor(relativePath)
+        ?.map((candidate) => candidate.routePattern);
 }
 /** The same answer with its evidence: every route, and the import chain that
  *  reaches the file from that route's entry file. */

package/build/utils/sourceRouteExtractor.js

@@ -135,7 +135,8 @@ function findRouterFiles(repoPath) {
             // hosts a `defineModule({ routes: [...] })` call.
             if (lower.startsWith("index.")) {
                 const ext = path.extname(lower);
-                return indexExtensions.has(ext) && full.includes(`${path.sep}modules${path.sep}`);
+                return (indexExtensions.has(ext) &&
+                    full.includes(`${path.sep}modules${path.sep}`));
             }
             return false;
         },
@@ -529,8 +530,10 @@ function resolveExportedSymbolToString(filePath, exportedName, cache, depth) {
                 // `export default <expr>` — direct default export.
                 return resolveExpressionToString(stmt.expression, filePath, imports, localConsts, cache, depth + 1);
             }
-            if (ts.isExportDeclaration(stmt) && stmt.exportClause &&
-                ts.isNamedExports(stmt.exportClause) && !stmt.moduleSpecifier) {
+            if (ts.isExportDeclaration(stmt) &&
+                stmt.exportClause &&
+                ts.isNamedExports(stmt.exportClause) &&
+                !stmt.moduleSpecifier) {
                 // `export { X as default }` — local re-export aliased as default.
                 for (const elt of stmt.exportClause.elements) {
                     if (elt.name.text !== "default")
@@ -643,7 +646,9 @@ function resolveModuleSpecifier(spec, fromDir, cache) {
     const viaPaths = resolveViaTsconfigPaths(spec, tsconfig);
     if (viaPaths)
         return viaPaths;
-    return tsconfig.baseUrl ? resolveImportPath(tsconfig.baseUrl, spec) : undefined;
+    return tsconfig.baseUrl
+        ? resolveImportPath(tsconfig.baseUrl, spec)
+        : undefined;
 }
 /** The file a `paths` alias names, trying the most specific pattern first and,
  *  within one pattern, the first target that exists. */
@@ -1052,7 +1057,8 @@ function dataRouterRoutesFromArray(arr, prefix, filePath, imports, localConsts,
             else if (name === "element" || name === "component") {
                 componentName = componentIdentifierOf(prop.initializer);
             }
-            else if (name === "children" && ts.isArrayLiteralExpression(prop.initializer)) {
+            else if (name === "children" &&
+                ts.isArrayLiteralExpression(prop.initializer)) {
                 childrenArray = prop.initializer;
             }
         }
@@ -1141,7 +1147,8 @@ function defineModuleRoutesFromCall(call, filePath, imports, localConsts, cache)
             if (idVal !== null)
                 moduleId = idVal;
         }
-        else if (propName === "routes" && ts.isArrayLiteralExpression(prop.initializer)) {
+        else if (propName === "routes" &&
+            ts.isArrayLiteralExpression(prop.initializer)) {
             routesArray = prop.initializer;
         }
     }

package/build/utils/telemetry.d.ts

@@ -14,6 +14,7 @@ export interface RepositoryInfo {
  * forms, with or without the trailing ".git". Returns undefined if no match.
  */
 export declare function parseRepositoryFromRemoteUrl(remoteUrl: string): RepositoryInfo | undefined;
+export declare function getLocalRepositoryInfo(cwd: string): Promise<RepositoryInfo>;
 /**
  * Resolves source-repository attribution for telemetry, segmenting usage per
  * customer/repo.

package/build/utils/telemetry.js

@@ -7,6 +7,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { isTestbotEnabled } from "./featureFlags.js";
 import { logger } from "./logger.js";
+import { parseOwnerRepo } from "./repositorySlug.js";
 const execFileAsync = promisify(execFile);
 export function getEntryPoint() {
     return isTestbotEnabled() ? "testbot" : "mcp";
@@ -32,17 +33,19 @@ export function getCIPlatform() {
  * forms, with or without the trailing ".git". Returns undefined if no match.
  */
 export function parseRepositoryFromRemoteUrl(remoteUrl) {
-    const match = remoteUrl.trim().match(/[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-    if (!match)
+    const repository = parseOwnerRepo(remoteUrl);
+    if (!repository)
         return undefined;
-    const [, owner, repo] = match;
-    return { repository: `${owner}/${repo}`, repositoryOwner: owner };
+    return { repository, repositoryOwner: repository.split("/")[0] };
 }
 // Memoize the local git lookup per working directory so we shell out at most
 // once per cwd for the lifetime of the MCP server process. The value is the
 // resolved RepositoryInfo (possibly empty when not a git repo / no remote).
+//
+// Also read outside telemetry: the testbot and SUT resources name their
+// repository from the checkout's own remote, the same way the action does.
 const localRepoInfoCache = new Map();
-async function getLocalRepositoryInfo(cwd) {
+export async function getLocalRepositoryInfo(cwd) {
     const cached = localRepoInfoCache.get(cwd);
     if (cached)
         return cached;

package/build/utils/testDependencyPolicy.d.ts

@@ -0,0 +1,9 @@
+export declare const NPM_TEST_PACKAGES: ReadonlySet<string>;
+export declare const PYTHON_TEST_PACKAGES: ReadonlySet<string>;
+export declare const JAVA_TEST_PACKAGES: ReadonlySet<string>;
+export interface TestDependencyVerification {
+    ok: boolean;
+    checkedFiles: string[];
+    violations: string[];
+}
+export declare function verifyTestDependencyChanges(repositoryPath: string): Promise<TestDependencyVerification>;