@expo/code-review-cli 0.11.1 → 0.12.1

package/build/research-mcp/html.js

@@ -0,0 +1,138 @@
+import { createHash } from "node:crypto";
+import * as cheerio from "cheerio";
+const discardedSelectors = [
+    "script",
+    "style",
+    "noscript",
+    "svg",
+    "nav",
+    "footer",
+    "form",
+    "button",
+    "[hidden]",
+    "[aria-hidden='true']",
+].join(",");
+const blockSelectors = [
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "br",
+    "dd",
+    "div",
+    "dl",
+    "dt",
+    "figcaption",
+    "figure",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "li",
+    "main",
+    "p",
+    "pre",
+    "section",
+    "table",
+    "td",
+    "th",
+    "tr",
+].join(",");
+function cleanText(value) {
+    return value
+        .replace(/\r/g, "")
+        .replace(/[ \t]+/g, " ")
+        .replace(/ *\n */g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function cleanTitle(value) {
+    return cleanText(value)
+        .replace(/\s*[|–—-]\s*Apple Developer Documentation$/i, "")
+        .replace(/\s*[|–—-]\s*Android Developers$/i, "")
+        .trim();
+}
+export function extractDocumentationPage(html, url, platform, source = {}) {
+    const $ = cheerio.load(html);
+    $(discardedSelectors).remove();
+    const main = $("main").first().length
+        ? $("main").first()
+        : $("article").first().length
+            ? $("article").first()
+            : $("[role='main']").first().length
+                ? $("[role='main']").first()
+                : $("body").first();
+    main.find(blockSelectors).each((_, element) => {
+        $(element).append("\n");
+    });
+    const body = cleanText(main.text());
+    const title = cleanTitle($("h1").first().text() || $("title").first().text());
+    if (!title || body.length < 80) {
+        return null;
+    }
+    const links = new Set();
+    $("a[href]").each((_, element) => {
+        const href = $(element).attr("href");
+        if (href) {
+            links.add(href);
+        }
+    });
+    return {
+        document: { platform, title, url, body, ...source },
+        links: [...links],
+    };
+}
+export function chunkDocument(document, indexedAt, targetCharacters = 1400, overlapCharacters = 180) {
+    const paragraphs = document.body
+        .split(/\n{2,}/)
+        .map((paragraph) => paragraph.trim())
+        .filter(Boolean);
+    const passages = [];
+    let current = "";
+    const flush = () => {
+        const passage = current.trim();
+        if (passage) {
+            passages.push(passage);
+        }
+        const overlapStart = Math.max(0, passage.length - overlapCharacters);
+        const overlapTail = passage.slice(overlapStart);
+        const sentenceBoundary = overlapTail.match(/[.!?]\s+/);
+        current =
+            sentenceBoundary?.index !== undefined
+                ? overlapTail.slice(sentenceBoundary.index + sentenceBoundary[0].length)
+                : "";
+    };
+    for (const paragraph of paragraphs) {
+        if (current && current.length + paragraph.length + 2 > targetCharacters) {
+            flush();
+        }
+        if (paragraph.length > targetCharacters * 2) {
+            let remaining = paragraph;
+            while (remaining.length > targetCharacters) {
+                const splitAt = remaining.lastIndexOf(" ", targetCharacters);
+                const boundary = splitAt > targetCharacters / 2 ? splitAt : targetCharacters;
+                current = `${current}\n\n${remaining.slice(0, boundary)}`.trim();
+                flush();
+                remaining = remaining.slice(boundary).trim();
+            }
+            current = `${current}\n\n${remaining}`.trim();
+        }
+        else {
+            current = `${current}\n\n${paragraph}`.trim();
+        }
+    }
+    flush();
+    const documentId = createHash("sha256")
+        .update(`${document.provider ?? document.platform}\0${document.url}\0${document.title}`)
+        .digest("hex")
+        .slice(0, 16);
+    return passages.map((passage, chunkIndex) => ({
+        ...document,
+        body: undefined,
+        id: `${document.provider ?? document.platform}:${documentId}#${chunkIndex}`,
+        passage,
+        indexedAt,
+    }));
+}

package/build/research-mcp/markdown.js

@@ -0,0 +1,32 @@
+export function extractMarkdownDocumentationPage(markdown, url, platform, source = {}) {
+    const sanitized = markdown
+        .replace(/<!--[^]*?-->/g, "")
+        .replace(/<script\b[^>]*>[^]*?<\/script>/gi, "")
+        .replace(/<style\b[^>]*>[^]*?<\/style>/gi, "")
+        .replace(/\r/g, "");
+    const withoutFrontMatter = sanitized.replace(/^---\n[^]*?\n---\n/, "");
+    const title = withoutFrontMatter.match(/^#\s+(.+)$/m)?.[1]?.trim() ??
+        withoutFrontMatter.match(/^([^\n]+)\n(?:=+|-+)\s*$/m)?.[1]?.trim() ??
+        "";
+    const body = withoutFrontMatter
+        .replace(/^#{1,6}\s+/gm, "")
+        .replace(/^(?:=+|-+)\s*$/gm, "")
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/[ \t]+/g, " ")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    if (!title || body.length < 80)
+        return null;
+    const links = [...sanitized.matchAll(/\[[^\]]+\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g)].flatMap((match) => (match[1] ? [match[1]] : []));
+    return {
+        document: {
+            platform,
+            title,
+            url,
+            body,
+            ...source,
+        },
+        links,
+    };
+}

package/build/research-mcp/okhttp-search.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { chunkDocument, extractDocumentationPage } from "./html.js";
+import { okHttpProvider, resolveAllowedUrl } from "./providers.js";
+import { readBodyWithLimit } from "./response.js";
+import { buildSearchIndex, searchDocumentation } from "./search-index.js";
+const OKHTTP_SEARCH_INDEX = "https://lysine.dev/okhttp/search/search_index.json";
+const OKHTTP_SEARCH_INDEX_LIMIT_BYTES = 1_000_000;
+const OKHTTP_SEARCH_TIMEOUT_MS = 10_000;
+const okHttpSearchIndexSchema = z.object({
+    docs: z
+        .array(z.object({
+        location: z.string().max(2_000),
+        title: z.string().min(1).max(500),
+        text: z.string().max(100_000),
+    }))
+        .max(1_000),
+});
+const indexCache = new WeakMap();
+async function loadOkHttpSearchIndex(fetchImplementation) {
+    const response = await fetchImplementation(OKHTTP_SEARCH_INDEX, {
+        redirect: "manual",
+        signal: AbortSignal.timeout(OKHTTP_SEARCH_TIMEOUT_MS),
+        headers: {
+            accept: "application/json",
+            "accept-language": "en-US,en;q=0.9",
+            "user-agent": "review-research-mcp/0.2 (+official documentation search index)",
+        },
+    });
+    if (response.status >= 300 && response.status < 400) {
+        throw new Error(`OkHttp search index unexpectedly redirected with HTTP ${response.status}`);
+    }
+    if (!response.ok) {
+        throw new Error(`OkHttp search index returned HTTP ${response.status}`);
+    }
+    const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+    if (!contentType.includes("application/json")) {
+        throw new Error(`OkHttp search index returned unsupported content type: ${contentType || "missing"}`);
+    }
+    const parsed = okHttpSearchIndexSchema.parse(JSON.parse(await readBodyWithLimit(response, OKHTTP_SEARCH_INDEX_LIMIT_BYTES)));
+    const indexedAt = new Date().toISOString();
+    const seenDocuments = new Set();
+    const documents = parsed.docs.flatMap((entry) => {
+        try {
+            const url = resolveAllowedUrl(okHttpProvider, entry.location, "https://lysine.dev/okhttp/");
+            const key = `${url.href}|${entry.title}`;
+            if (seenDocuments.has(key))
+                return [];
+            seenDocuments.add(key);
+            const extracted = extractDocumentationPage(`<!doctype html><html><body><main><h1>${entry.title}</h1>${entry.text}</main></body></html>`, url.href, "android", { provider: "okhttp", sourceKind: "official-guide" });
+            return extracted ? [extracted.document] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    const chunks = documents.flatMap((document) => chunkDocument(document, indexedAt));
+    return buildSearchIndex(chunks, documents.length, indexedAt);
+}
+function cachedOkHttpSearchIndex(fetchImplementation) {
+    const cached = indexCache.get(fetchImplementation);
+    if (cached)
+        return cached;
+    const pending = loadOkHttpSearchIndex(fetchImplementation);
+    indexCache.set(fetchImplementation, pending);
+    return pending;
+}
+export async function searchOkHttpDocumentation(query, limit, fetchImplementation = fetch) {
+    const index = await cachedOkHttpSearchIndex(fetchImplementation);
+    const search = (value) => searchDocumentation(index, value, {
+        platform: "android",
+        providers: ["okhttp"],
+        sourceKinds: ["official-guide"],
+        limit,
+    });
+    const conceptTokens = [...new Set(query.match(/\b[a-z][a-z0-9-]{3,}\b/g) ?? [])];
+    const concepts = conceptTokens.join(" ");
+    const candidates = concepts && concepts !== query
+        ? [
+            ...conceptTokens.flatMap((concept) => search(concept).slice(0, 1)),
+            ...search(concepts),
+            ...search(query),
+        ]
+        : search(query);
+    const seen = new Set();
+    return candidates
+        .filter((result) => {
+        const key = `${result.url}|${result.title}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    })
+        .slice(0, limit);
+}

package/build/research-mcp/paths.js

@@ -0,0 +1,4 @@
+import { fileURLToPath } from "node:url";
+export const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+export const defaultConfigPath = fileURLToPath(new URL("../../research/sources.json", import.meta.url));
+export const defaultIndexPath = fileURLToPath(new URL("../../research/data/docs-index.json", import.meta.url));

package/build/research-mcp/providers.js

@@ -0,0 +1,322 @@
+function isSecurePublicUrl(url, hostname) {
+    return (url.protocol === "https:" &&
+        url.hostname === hostname &&
+        (url.port === "" || url.port === "443") &&
+        url.username === "" &&
+        url.password === "");
+}
+function hasAllowedPath(url, prefixes) {
+    return prefixes.some((prefix) => url.pathname === prefix || url.pathname.startsWith(`${prefix}/`));
+}
+function acceptsOrigin(url, origins) {
+    return origins.some(({ hostname, prefixes }) => isSecurePublicUrl(url, hostname) && hasAllowedPath(url, prefixes));
+}
+function canonicalizeDocumentationUrl(url) {
+    const canonical = new URL(url.href);
+    canonical.hash = "";
+    canonical.search = "";
+    canonical.hostname = canonical.hostname.toLowerCase();
+    canonical.pathname = canonical.pathname.replace(/\/{2,}/g, "/");
+    if (canonical.pathname.length > 1) {
+        canonical.pathname = canonical.pathname.replace(/\/$/, "");
+    }
+    return canonical;
+}
+function htmlProvider(id, platform, displayName, origins, preserveTrailingSlash = false) {
+    return {
+        id,
+        platform,
+        displayName,
+        accepts(url) {
+            return acceptsOrigin(url, origins);
+        },
+        acceptsRequest(url) {
+            return this.accepts(url);
+        },
+        canonicalize(url) {
+            const hadTrailingSlash = url.pathname.endsWith("/");
+            const canonical = canonicalizeDocumentationUrl(url);
+            if (preserveTrailingSlash && hadTrailingSlash && !canonical.pathname.endsWith("/")) {
+                canonical.pathname += "/";
+            }
+            return canonical;
+        },
+        requestUrl(documentUrl) {
+            if (preserveTrailingSlash && !documentUrl.pathname.endsWith("/")) {
+                const request = new URL(documentUrl.href);
+                request.pathname += "/";
+                return request;
+            }
+            return documentUrl;
+        },
+        responseFormat() {
+            return "html";
+        },
+    };
+}
+function appleDocCProvider(id, displayName, prefixes) {
+    return {
+        id,
+        platform: "apple",
+        displayName,
+        accepts(url) {
+            return isSecurePublicUrl(url, "developer.apple.com") && hasAllowedPath(url, prefixes);
+        },
+        acceptsRequest(url) {
+            if (this.accepts(url))
+                return true;
+            if (!isSecurePublicUrl(url, "developer.apple.com") ||
+                !url.pathname.startsWith("/tutorials/data/documentation/") ||
+                !url.pathname.endsWith(".json")) {
+                return false;
+            }
+            const correspondingDocumentUrl = new URL(url.href);
+            correspondingDocumentUrl.pathname = url.pathname
+                .slice("/tutorials/data".length)
+                .replace(/\.json$/, "");
+            return hasAllowedPath(correspondingDocumentUrl, prefixes);
+        },
+        canonicalize: canonicalizeDocumentationUrl,
+        requestUrl(documentUrl) {
+            if (documentUrl.pathname.startsWith("/documentation/")) {
+                return new URL(`/tutorials/data${documentUrl.pathname.toLowerCase()}.json`, documentUrl.origin);
+            }
+            return documentUrl;
+        },
+        responseFormat(documentUrl) {
+            return documentUrl.pathname.startsWith("/documentation/") ? "docc-json" : "html";
+        },
+    };
+}
+export const appleProvider = appleDocCProvider("apple", "Apple Developer Documentation", [
+    "/documentation",
+    "/design/human-interface-guidelines",
+]);
+export const appleReleasesProvider = appleDocCProvider("apple-releases", "Apple platform and Xcode release notes", [
+    "/documentation/xcode-release-notes",
+    "/documentation/ios-ipados-release-notes",
+    "/documentation/macos-release-notes",
+    "/documentation/tvos-release-notes",
+    "/documentation/watchos-release-notes",
+    "/documentation/visionos-release-notes",
+]);
+const swiftEvolutionOrigins = [
+    { hostname: "www.swift.org", prefixes: ["/swift-evolution"] },
+    {
+        hostname: "github.com",
+        prefixes: ["/swiftlang/swift-evolution/blob/main/proposals"],
+    },
+];
+export const swiftEvolutionProvider = {
+    id: "swift-evolution",
+    platform: "apple",
+    displayName: "Swift Evolution",
+    accepts(url) {
+        return acceptsOrigin(url, swiftEvolutionOrigins);
+    },
+    acceptsRequest(url) {
+        return (this.accepts(url) ||
+            (isSecurePublicUrl(url, "raw.githubusercontent.com") &&
+                hasAllowedPath(url, ["/swiftlang/swift-evolution/refs/heads/main/proposals"])));
+    },
+    canonicalize: canonicalizeDocumentationUrl,
+    requestUrl(documentUrl) {
+        const match = documentUrl.pathname.match(/^\/swiftlang\/swift-evolution\/blob\/main\/proposals\/(.+\.md)$/);
+        return match
+            ? new URL(`https://raw.githubusercontent.com/swiftlang/swift-evolution/refs/heads/main/proposals/${match[1]}`)
+            : documentUrl;
+    },
+    responseFormat(documentUrl) {
+        return documentUrl.hostname === "github.com" ? "markdown" : "html";
+    },
+};
+const androidPrefixes = [
+    "/build",
+    "/develop",
+    "/guide",
+    "/jetpack",
+    "/kotlin",
+    "/reference",
+    "/studio",
+    "/topic",
+    "/training",
+];
+export const androidProvider = htmlProvider("android", "android", "Android and Google Play services documentation", [
+    { hostname: "developer.android.com", prefixes: androidPrefixes },
+    { hostname: "developers.google.com", prefixes: ["/android/reference"] },
+]);
+export const androidReleasesProvider = htmlProvider("android-releases", "android", "Android platform release notes and behavior changes", [{ hostname: "developer.android.com", prefixes: ["/about/versions"] }]);
+export const media3Provider = htmlProvider("media3", "android", "Jetpack Media3 documentation", [
+    {
+        hostname: "developer.android.com",
+        prefixes: ["/media/media3", "/jetpack/androidx/releases/media3", "/reference/androidx/media3"],
+    },
+]);
+export const glideProvider = htmlProvider("glide", "android", "Glide documentation", [
+    {
+        hostname: "bumptech.github.io",
+        prefixes: ["/glide/doc", "/glide/javadocs"],
+    },
+]);
+// OkHttp moved from Square to the Commonhaus-backed Lysine organization in 2026.
+// The maintainer and Commonhaus independently document the transfer:
+// https://jakewharton.com/the-lysine-contingency/
+// https://www.commonhaus.org/activity/315.html
+// Use its canonical project domain instead of coupling trust to either GitHub owner name.
+export const okHttpProvider = htmlProvider("okhttp", "android", "OkHttp project documentation", [
+    { hostname: "lysine.dev", prefixes: ["/okhttp"] },
+]);
+export const kotlinCoroutinesProvider = htmlProvider("kotlin-coroutines", "android", "Kotlin coroutines documentation", [
+    {
+        hostname: "kotlinlang.org",
+        prefixes: ["/docs", "/api/kotlinx.coroutines"],
+    },
+]);
+export const gradleProvider = htmlProvider("gradle", "android", "Gradle documentation", [
+    { hostname: "docs.gradle.org", prefixes: ["/current"] },
+]);
+export const agpProvider = htmlProvider("agp", "android", "Android Gradle plugin documentation", [
+    {
+        hostname: "developer.android.com",
+        prefixes: ["/build", "/reference/tools/gradle-api"],
+    },
+]);
+const jetbrainsIssueOrigins = [
+    {
+        hostname: "youtrack.jetbrains.com",
+        prefixes: ["/issue", "/projects/IDEA/issues"],
+    },
+];
+export const jetbrainsIssuesProvider = {
+    id: "jetbrains-issues",
+    platform: "android",
+    displayName: "JetBrains YouTrack issues",
+    accepts(url) {
+        return acceptsOrigin(url, jetbrainsIssueOrigins);
+    },
+    acceptsRequest(url) {
+        return (this.accepts(url) ||
+            (isSecurePublicUrl(url, "youtrack.jetbrains.com") &&
+                /^\/api\/issues\/[A-Z][A-Z0-9]+-\d+$/.test(url.pathname)));
+    },
+    canonicalize: canonicalizeDocumentationUrl,
+    requestUrl(documentUrl) {
+        const issueId = documentUrl.pathname.match(/(?:^|\/)([A-Z][A-Z0-9]+-\d+)(?:\/|$)/)?.[1];
+        if (!issueId)
+            return documentUrl;
+        const request = new URL(`https://youtrack.jetbrains.com/api/issues/${issueId}`);
+        request.searchParams.set("fields", "idReadable,summary,description,customFields(name,value(name)),comments(text,author(name),created)");
+        return request;
+    },
+    responseFormat() {
+        return "youtrack-json";
+    },
+};
+export const expoProvider = htmlProvider("expo", "react-native", "Expo documentation", [
+    { hostname: "docs.expo.dev", prefixes: [""] },
+]);
+export const reactNativeProvider = htmlProvider("react-native", "react-native", "React Native documentation", [
+    {
+        hostname: "reactnative.dev",
+        prefixes: ["/docs", "/architecture"],
+    },
+]);
+export const reactNativeReanimatedProvider = htmlProvider("react-native-reanimated", "react-native", "React Native Reanimated documentation", [
+    {
+        hostname: "docs.swmansion.com",
+        prefixes: ["/react-native-reanimated/docs"],
+    },
+], true);
+export const reactNativeGestureHandlerProvider = htmlProvider("react-native-gesture-handler", "react-native", "React Native Gesture Handler documentation", [
+    {
+        hostname: "docs.swmansion.com",
+        prefixes: ["/react-native-gesture-handler/docs"],
+    },
+], true);
+const reactNativeScreensOrigins = [
+    { hostname: "docs.swmansion.com", prefixes: ["/react-native-screens"] },
+    {
+        hostname: "github.com",
+        prefixes: ["/software-mansion/react-native-screens/blob/main/README.md"],
+    },
+];
+export const reactNativeScreensProvider = {
+    id: "react-native-screens",
+    platform: "react-native",
+    displayName: "React Native Screens documentation",
+    accepts(url) {
+        return acceptsOrigin(url, reactNativeScreensOrigins);
+    },
+    acceptsRequest(url) {
+        return (this.accepts(url) ||
+            (isSecurePublicUrl(url, "raw.githubusercontent.com") &&
+                hasAllowedPath(url, ["/software-mansion/react-native-screens/refs/heads/main/README.md"])));
+    },
+    canonicalize: canonicalizeDocumentationUrl,
+    requestUrl(documentUrl) {
+        return documentUrl.hostname === "github.com"
+            ? new URL("https://raw.githubusercontent.com/software-mansion/react-native-screens/refs/heads/main/README.md")
+            : documentUrl;
+    },
+    responseFormat(documentUrl) {
+        return documentUrl.hostname === "github.com" ? "markdown" : "html";
+    },
+};
+export const reactNativeWorkletsProvider = htmlProvider("react-native-worklets", "react-native", "React Native Worklets documentation", [
+    {
+        hostname: "docs.swmansion.com",
+        prefixes: ["/react-native-worklets/docs"],
+    },
+], true);
+const providers = {
+    apple: appleProvider,
+    "apple-releases": appleReleasesProvider,
+    "swift-evolution": swiftEvolutionProvider,
+    android: androidProvider,
+    "android-releases": androidReleasesProvider,
+    media3: media3Provider,
+    glide: glideProvider,
+    okhttp: okHttpProvider,
+    "kotlin-coroutines": kotlinCoroutinesProvider,
+    gradle: gradleProvider,
+    agp: agpProvider,
+    "jetbrains-issues": jetbrainsIssuesProvider,
+    expo: expoProvider,
+    "react-native": reactNativeProvider,
+    "react-native-reanimated": reactNativeReanimatedProvider,
+    "react-native-gesture-handler": reactNativeGestureHandlerProvider,
+    "react-native-screens": reactNativeScreensProvider,
+    "react-native-worklets": reactNativeWorkletsProvider,
+};
+export function getProvider(provider) {
+    return providers[provider];
+}
+export function resolveAllowedUrl(provider, rawUrl, baseUrl) {
+    let parsed;
+    try {
+        parsed = baseUrl ? new URL(rawUrl, baseUrl) : new URL(rawUrl);
+    }
+    catch {
+        throw new Error(`Invalid ${provider.id} documentation URL`);
+    }
+    const canonical = provider.canonicalize(parsed);
+    if (!provider.accepts(canonical)) {
+        throw new Error(`URL is outside the ${provider.id} documentation allowlist`);
+    }
+    return canonical;
+}
+export function resolveAllowedRequestUrl(provider, rawUrl, baseUrl) {
+    let parsed;
+    try {
+        parsed = baseUrl ? new URL(rawUrl, baseUrl) : new URL(rawUrl);
+    }
+    catch {
+        throw new Error(`Invalid ${provider.id} request URL`);
+    }
+    parsed.hash = "";
+    parsed.hostname = parsed.hostname.toLowerCase();
+    if (!provider.acceptsRequest(parsed)) {
+        throw new Error(`Request URL is outside the ${provider.id} network allowlist`);
+    }
+    return parsed;
+}