@topogram/cli 0.3.34

package/src/import/extractors/ui/next-pages-router.js

@@ -0,0 +1,141 @@
+import path from "node:path";
+
+import {
+  dedupeCandidateRecords,
+  findImportFiles,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase,
+  idHintify
+} from "../../core/shared.js";
+
+function pagesRoutePath(pagesRoot, filePath) {
+  const relative = relativeTo(pagesRoot, filePath);
+  return `/${relative}`
+    .replace(/\.(tsx|ts|jsx|js|mdx)$/, "")
+    .replace(/\/index$/, "")
+    .replace(/\[(\.\.\.)?([^\]]+)\]/g, (_match, catchAll, name) => catchAll ? `:${name}*` : `:${name}`)
+    .replace(/^\/$/, "/") || "/";
+}
+
+function inferTrpcHooks(text) {
+  const hooks = [];
+  for (const match of String(text || "").matchAll(/trpc\.([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\.use(Query|InfiniteQuery|Mutation)\b/g)) {
+    hooks.push({
+      router: match[1],
+      procedure: match[2],
+      hook: match[3]
+    });
+  }
+  return hooks;
+}
+
+function screenFromRouteAndHooks(routePath, hooks) {
+  const hasPostHooks = hooks.some((hook) => hook.router === "post");
+  if (routePath === "/" && hasPostHooks) return { id: "post_list", kind: "list", entity: "entity_post", concept: "entity_post" };
+  if (/^\/post\/:[^/]+$/.test(routePath) && hasPostHooks) return { id: "post_detail", kind: "detail", entity: "entity_post", concept: "entity_post" };
+  if (routePath === "/") return { id: "home", kind: "flow", entity: null, concept: "surface_home" };
+  const resource = routePath.split("/").filter(Boolean)[0] || "home";
+  const normalized = resource.replace(/[^a-zA-Z0-9]+/g, "_").toLowerCase();
+  const kind = /\/:[^/]+$/.test(routePath) ? "detail" : "list";
+  return {
+    id: kind === "detail" ? `${normalized}_detail` : `${normalized}_list`,
+    kind,
+    entity: normalized === "home" ? null : `entity_${normalized}`,
+    concept: normalized === "home" ? "surface_home" : `entity_${normalized}`
+  };
+}
+
+function capabilityHint(router, procedure) {
+  const resource = router.toLowerCase();
+  if (procedure === "list") return `cap_list_${resource}s`;
+  if (procedure === "byId") return `cap_get_${resource}`;
+  if (procedure === "add") return `cap_create_${resource}`;
+  return `cap_${idHintify(`${procedure}_${resource}`)}`;
+}
+
+export const nextPagesRouterUiExtractor = {
+  id: "ui.next-pages-router",
+  track: "ui",
+  detect(context) {
+    const pageFiles = findImportFiles(context.paths, (filePath) => /src\/pages\/.+\.(tsx|ts|jsx|js|mdx)$/i.test(filePath))
+      .filter((filePath) => !/\/api\//.test(filePath) && !/\/_(app|document|error)\./.test(filePath) && !/\/404\./.test(filePath));
+    return {
+      score: pageFiles.length > 0 ? 85 : 0,
+      reasons: pageFiles.length > 0 ? ["Found Next.js Pages Router pages"] : []
+    };
+  },
+  extract(context) {
+    const pagesRoot = path.join(context.paths.workspaceRoot, "src", "pages");
+    const pageFiles = findImportFiles(context.paths, (filePath) => /src\/pages\/.+\.(tsx|ts|jsx|js|mdx)$/i.test(filePath))
+      .filter((filePath) => !/\/api\//.test(filePath) && !/\/_(app|document|error)\./.test(filePath) && !/\/404\./.test(filePath));
+    const findings = [];
+    const candidates = { screens: [], routes: [], actions: [], stacks: [] };
+    if (pageFiles.length > 0) {
+      const routes = [];
+      for (const filePath of pageFiles) {
+        const routePath = pagesRoutePath(pagesRoot, filePath);
+        const text = context.helpers.readTextIfExists(filePath) || "";
+        const hooks = inferTrpcHooks(text);
+        const screen = screenFromRouteAndHooks(routePath, hooks);
+        const provenance = `${relativeTo(context.paths.repoRoot, filePath)}#${routePath}`;
+        routes.push(routePath);
+        candidates.screens.push(makeCandidateRecord({
+          kind: "screen",
+          idHint: screen.id,
+          label: titleCase(screen.id),
+          confidence: "medium",
+          sourceKind: "route_code",
+          provenance,
+          track: "ui",
+          entity_id: screen.entity,
+          concept_id: screen.concept,
+          screen_kind: screen.kind,
+          route_path: routePath,
+          capability_hints: hooks.map((hook) => capabilityHint(hook.router, hook.procedure))
+        }));
+        candidates.routes.push(makeCandidateRecord({
+          kind: "ui_route",
+          idHint: `${screen.id}_route`,
+          label: routePath,
+          confidence: "medium",
+          sourceKind: "route_code",
+          provenance,
+          track: "ui",
+          screen_id: screen.id,
+          entity_id: screen.entity,
+          concept_id: screen.concept,
+          path: routePath
+        }));
+        for (const hook of hooks.filter((hook) => hook.hook === "Mutation")) {
+          const capability = capabilityHint(hook.router, hook.procedure);
+          candidates.actions.push(makeCandidateRecord({
+            kind: "ui_action",
+            idHint: `${screen.id}_${idHintify(capability)}`,
+            label: capability,
+            confidence: "medium",
+            sourceKind: "route_code",
+            provenance,
+            track: "ui",
+            screen_id: screen.id,
+            entity_id: screen.entity,
+            concept_id: screen.concept,
+            capability_hint: capability,
+            prominence: "primary"
+          }));
+        }
+      }
+      findings.push({
+        kind: "next_pages_routes",
+        file: relativeTo(context.paths.repoRoot, pagesRoot),
+        routes: [...new Set(routes)].sort()
+      });
+      candidates.stacks.push("next_pages_router");
+    }
+    candidates.screens = dedupeCandidateRecords(candidates.screens, (record) => record.id_hint);
+    candidates.routes = dedupeCandidateRecords(candidates.routes, (record) => record.id_hint);
+    candidates.actions = dedupeCandidateRecords(candidates.actions, (record) => record.id_hint);
+    candidates.stacks = [...new Set(candidates.stacks)].sort();
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/ui/razor-pages.js

@@ -0,0 +1,181 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function shouldIgnoreFile(filePath) {
+  return /\/obj\/|\/bin\/|\/_ViewImports\.cshtml$|\/_ViewStart\.cshtml$|\/Shared\/_|\/Views\/Shared\/|\/Pages\/Shared\/|\/_[^/]+\.cshtml$/.test(filePath);
+}
+
+function inferFromPath(repoRelativePath) {
+  const normalized = repoRelativePath.replace(/\\/g, "/");
+  if (/\/Pages\/Basket\/Index\.cshtml$/.test(normalized)) return { screenId: "basket", conceptId: "surface_basket", entityId: "entity_basket", routePath: "/basket", screenKind: "list" };
+  if (/\/Pages\/Basket\/Checkout\.cshtml$/.test(normalized)) return { screenId: "basket_checkout", conceptId: "surface_basket", entityId: "entity_basket", routePath: "/basket/checkout", screenKind: "form" };
+  if (/\/Pages\/Basket\/Success\.cshtml$/.test(normalized)) return { screenId: "basket_success", conceptId: "surface_basket", entityId: "entity_basket", routePath: "/basket/success", screenKind: "detail" };
+  if (/\/Pages\/Admin\/Index\.cshtml$/.test(normalized)) return { screenId: "catalog_item_admin", conceptId: "surface_catalog_item_admin", entityId: "entity_catalog-item", routePath: "/admin", screenKind: "list" };
+  if (/\/Pages\/Admin\/EditCatalogItem\.cshtml$/.test(normalized)) return { screenId: "catalog_item_admin_edit", conceptId: "surface_catalog_item_admin", entityId: "entity_catalog-item", routePath: "/admin/edit-catalog-item", screenKind: "form" };
+  if (/\/Pages\/Index\.cshtml$/.test(normalized)) return { screenId: "catalog_home", conceptId: "surface_catalog", entityId: "entity_item", routePath: "/", screenKind: "list" };
+  if (/\/Pages\/Privacy\.cshtml$/.test(normalized)) return { screenId: "privacy", conceptId: "surface_app", entityId: null, routePath: "/privacy", screenKind: "detail" };
+  if (/\/Pages\/Error\.cshtml$/.test(normalized)) return { screenId: "error", conceptId: "surface_app", entityId: null, routePath: "/error", screenKind: "detail" };
+  if (/\/Areas\/Identity\/Pages\/Account\/Login\.cshtml$/.test(normalized)) return { screenId: "account_login", conceptId: "surface_account", entityId: null, routePath: "/account/login", screenKind: "auth" };
+  if (/\/Areas\/Identity\/Pages\/Account\/Register\.cshtml$/.test(normalized)) return { screenId: "account_register", conceptId: "surface_account", entityId: null, routePath: "/account/register", screenKind: "auth" };
+  if (/\/Areas\/Identity\/Pages\/Account\/Logout\.cshtml$/.test(normalized)) return { screenId: "account_logout_page", conceptId: "surface_account", entityId: null, routePath: "/account/logout", screenKind: "auth" };
+  if (/\/Areas\/Identity\/Pages\/Account\/ConfirmEmail\.cshtml$/.test(normalized)) return { screenId: "account_confirm_email", conceptId: "surface_account", entityId: null, routePath: "/account/confirm-email", screenKind: "auth" };
+  if (/\/Views\/Account\//.test(normalized)) {
+    const base = normalized.split("/").pop()?.replace(/\.cshtml$/i, "") || "account";
+    const stem = idHintify(canonicalCandidateTerm(base.replace(/([a-z0-9])([A-Z])/g, "$1_$2")));
+    return { screenId: stem, conceptId: "surface_account", entityId: null, routePath: `/account/${stem.replace(/_/g, "-")}`, screenKind: "auth" };
+  }
+  if (/\/Views\/Order\/MyOrders\.cshtml$/.test(normalized)) return { screenId: "order_list", conceptId: "surface_order", entityId: "entity_order", routePath: "/order/my-orders", screenKind: "list" };
+  if (/\/Views\/Order\/Detail\.cshtml$/.test(normalized)) return { screenId: "order_detail", conceptId: "surface_order", entityId: "entity_order", routePath: "/order/detail", screenKind: "detail" };
+  if (/\/Views\/Manage\//.test(normalized)) {
+    const base = normalized.split("/").pop()?.replace(/\.cshtml$/i, "") || "manage";
+    const stem = idHintify(canonicalCandidateTerm(base.replace(/([a-z0-9])([A-Z])/g, "$1_$2")));
+    return { screenId: stem, conceptId: "surface_account", entityId: null, routePath: `/manage/${stem.replace(/_/g, "-")}`, screenKind: "settings" };
+  }
+
+  const base = normalized.split("/").pop()?.replace(/\.cshtml$/i, "") || "view";
+  const stem = idHintify(canonicalCandidateTerm(base.replace(/([a-z0-9])([A-Z])/g, "$1_$2")));
+  return {
+    screenId: stem,
+    conceptId: `surface_${stem}`,
+    entityId: null,
+    routePath: `/${stem.replace(/_/g, "-")}`,
+    screenKind: /login|register|logout|account/.test(stem) ? "auth" : /edit|checkout|change/.test(stem) ? "form" : "detail"
+  };
+}
+
+function routePathForPage(text, fallback) {
+  const match = String(text || "").match(/@page\s+"([^"]+)"/);
+  return match ? match[1] : fallback;
+}
+
+function capabilityHints(text, repoRelativePath, screenId) {
+  const source = String(text || "");
+  const hints = [];
+  if (/asp-page-handler="Update"|name="updatebutton"/.test(source)) hints.push("cap_update_basket");
+  if (/asp-page="\.\/Checkout"|Checkout/.test(source) && /basket/i.test(screenId)) hints.push("cap_checkout_basket");
+  if (/asp-controller="Order"\s+asp-action="Detail"|Order\/Detail/.test(source)) hints.push("cap_get_order");
+  if (/asp-controller="Order"\s+asp-action="cancel"/i.test(source)) hints.push("cap_cancel_order");
+  if (/method="post"/.test(source) && /login/i.test(repoRelativePath)) hints.push("cap_sign_in_account");
+  if (/method="post"/.test(source) && /register/i.test(repoRelativePath)) hints.push("cap_register_account");
+  if (/EditCatalogItem|asp-page="\/Admin\/EditCatalogItem"/.test(source)) hints.push("cap_update_catalog_item");
+  if (/Products|CatalogItem|ProductName/.test(source) && /catalog|admin/i.test(repoRelativePath)) hints.push("cap_list_catalog_items");
+  return [...new Set(hints)];
+}
+
+function shellPatterns(text) {
+  const source = String(text || "");
+  return [
+    /<form\b/.test(source) ? "form_post" : null,
+    /asp-page=|asp-controller=|asp-action=/.test(source) ? "server_navigation" : null
+  ].filter(Boolean);
+}
+
+export const razorPagesUiExtractor = {
+  id: "ui.razor-pages",
+  track: "ui",
+  detect(context) {
+    const files = findImportFiles(context.paths, (filePath) => /\.cshtml$/i.test(filePath))
+      .filter((filePath) => !shouldIgnoreFile(filePath));
+    const score = files.length > 0 ? 84 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found Razor Pages / MVC .cshtml views"] : []
+    };
+  },
+  extract(context) {
+    const files = findImportFiles(context.paths, (filePath) => /\.cshtml$/i.test(filePath))
+      .filter((filePath) => !shouldIgnoreFile(filePath));
+    const findings = [];
+    const candidates = { screens: [], routes: [], actions: [], stacks: [] };
+
+    for (const filePath of files) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const repoRelativePath = relativeTo(context.paths.repoRoot, filePath);
+      const inferred = inferFromPath(repoRelativePath);
+      const routePath = routePathForPage(text, inferred.routePath);
+      const hints = capabilityHints(text, repoRelativePath, inferred.screenId);
+
+      candidates.screens.push(makeCandidateRecord({
+        kind: "screen",
+        idHint: inferred.screenId,
+        label: titleCase(inferred.screenId),
+        confidence: /@page|Views\//.test(repoRelativePath) ? "high" : "medium",
+        sourceKind: /@page/.test(text) ? "route_code" : "view_code",
+        provenance: repoRelativePath,
+        track: "ui",
+        entity_id: inferred.entityId,
+        concept_id: inferred.conceptId,
+        screen_kind: inferred.screenKind,
+        route_path: routePath,
+        capability_hints: hints
+      }));
+
+      candidates.routes.push(makeCandidateRecord({
+        kind: "ui_route",
+        idHint: `${inferred.screenId}_route`,
+        label: routePath,
+        confidence: /@page/.test(text) ? "high" : "medium",
+        sourceKind: /@page/.test(text) ? "route_code" : "view_code",
+        provenance: repoRelativePath,
+        track: "ui",
+        screen_id: inferred.screenId,
+        entity_id: inferred.entityId,
+        concept_id: inferred.conceptId,
+        path: routePath
+      }));
+
+      for (const hint of hints) {
+        candidates.actions.push(makeCandidateRecord({
+          kind: "ui_action",
+          idHint: `${inferred.screenId}_${idHintify(hint)}`,
+          label: hint,
+          confidence: "medium",
+          sourceKind: "view_code",
+          provenance: repoRelativePath,
+          track: "ui",
+          screen_id: inferred.screenId,
+          entity_id: inferred.entityId,
+          concept_id: inferred.conceptId,
+          capability_hint: hint,
+          prominence: /sign|register|checkout|cancel|update/.test(hint) ? "primary" : "secondary"
+        }));
+      }
+
+      for (const pattern of shellPatterns(text)) {
+        candidates.actions.push(makeCandidateRecord({
+          kind: "ui_navigation",
+          idHint: `razor_${idHintify(pattern)}`,
+          label: pattern,
+          confidence: "low",
+          sourceKind: "view_code",
+          provenance: repoRelativePath,
+          track: "ui",
+          navigation_pattern: pattern
+        }));
+      }
+
+      findings.push({
+        kind: "razor_view",
+        file: repoRelativePath,
+        screen_id: inferred.screenId
+      });
+    }
+
+    if (candidates.screens.length > 0) {
+      candidates.stacks.push("razor_pages");
+    }
+
+    candidates.screens = dedupeCandidateRecords(candidates.screens, (record) => record.id_hint);
+    candidates.routes = dedupeCandidateRecords(candidates.routes, (record) => record.id_hint);
+    candidates.actions = dedupeCandidateRecords(candidates.actions, (record) => record.id_hint);
+    candidates.stacks = [...new Set(candidates.stacks)].sort();
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/ui/react-native-screens.js

@@ -0,0 +1,166 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function featureStemFromPath(filePath) {
+  return canonicalCandidateTerm(filePath.match(/\/src\/([^/]+)\//)?.[1] || "item");
+}
+
+function inferScreenId(filePath) {
+  const fileStem = filePath.split("/").pop()?.replace(/\.tsx$/, "") || "screen";
+  const normalized = fileStem
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z])([A-Z][a-z])/g, "$1_$2");
+  return idHintify(normalized)
+    .replace(/_screen$/, "")
+    .replace(/^posts$/, "post_list")
+    .replace(/^post$/, "post_detail");
+}
+
+function inferScreenKind(screenId) {
+  if (/detail$/.test(screenId)) return "detail";
+  if (/list$/.test(screenId)) return "list";
+  return "flow";
+}
+
+function inferRoutePath(featureStem, screenId) {
+  if (screenId === `${featureStem}s` || screenId === `${featureStem}_list`) {
+    return `/${featureStem}s`;
+  }
+  if (screenId === featureStem || screenId === `${featureStem}_detail`) {
+    return `/${featureStem}s/:id`;
+  }
+  return `/${screenId.replace(/_/g, "-")}`;
+}
+
+function parseNavigatorRoutes(text) {
+  const routes = new Map();
+  for (const match of String(text || "").matchAll(/<Stack\.Screen\s+name="([^"]+)"\s+component=\{([A-Za-z_][A-Za-z0-9_]*)\}\s*\/>/g)) {
+    routes.set(match[2], match[1]);
+  }
+  return routes;
+}
+
+function parseScreenFile(filePath, text, repoRoot, routeNamesByComponent) {
+  const componentMatch =
+    String(text || "").match(/export\s+default\s+function\s+([A-Za-z_][A-Za-z0-9_]*)/) ||
+    String(text || "").match(/const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:observer\()?/);
+  if (!componentMatch) return null;
+  const componentName = componentMatch[1];
+  if (/NotFound/i.test(componentName)) return null;
+  const featureStem = featureStemFromPath(filePath);
+  const screenId = inferScreenId(filePath);
+  const routeName = routeNamesByComponent.get(componentName) || componentName.replace(/Screen$/, "");
+  const routePath =
+    routeName === "Posts" ? `/${featureStem}s`
+    : routeName === "Post" ? `/${featureStem}s/:id`
+    : inferRoutePath(featureStem, screenId);
+  const entityId = `entity_${featureStem}`;
+  const provenance = `${relativeTo(repoRoot, filePath)}#${componentName}`;
+  const capabilityHints = [];
+  if (/getPosts\(/.test(text) || /FlatList/.test(text)) {
+    capabilityHints.push(`cap_list_${featureStem}s`);
+  }
+  if (/findPost\(/.test(text) || /route\.params/.test(text)) {
+    capabilityHints.push(`cap_get_${featureStem}`);
+  }
+  return {
+    screen: makeCandidateRecord({
+      kind: "screen",
+      idHint: screenId,
+      label: titleCase(screenId),
+      confidence: "high",
+      sourceKind: "route_code",
+      provenance,
+      track: "ui",
+      entity_id: entityId,
+      concept_id: entityId,
+      screen_kind: inferScreenKind(screenId),
+      route_path: routePath,
+      capability_hints: capabilityHints
+    }),
+    route: makeCandidateRecord({
+      kind: "ui_route",
+      idHint: `${screenId}_route`,
+      label: routePath,
+      confidence: "high",
+      sourceKind: "route_code",
+      provenance,
+      track: "ui",
+      screen_id: screenId,
+      entity_id: entityId,
+      concept_id: entityId,
+      path: routePath
+    }),
+    actions: capabilityHints.map((capabilityHint) => makeCandidateRecord({
+      kind: "ui_action",
+      idHint: `${screenId}_${idHintify(capabilityHint)}`,
+      label: capabilityHint,
+      confidence: "medium",
+      sourceKind: "route_code",
+      provenance,
+      track: "ui",
+      screen_id: screenId,
+      entity_id: entityId,
+      concept_id: entityId,
+      capability_hint: capabilityHint,
+      prominence: "primary"
+    }))
+  };
+}
+
+export const reactNativeScreensExtractor = {
+  id: "ui.react-native-screens",
+  track: "ui",
+  detect(context) {
+    const files = findImportFiles(
+      context.paths,
+      (filePath) => /\/src\/.+\/presentation\/screens\/.+Screen\.tsx$/i.test(filePath)
+    );
+    const score = files.length > 0 ? 83 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found React Native presentation screens"] : []
+    };
+  },
+  extract(context) {
+    const screenFiles = findImportFiles(
+      context.paths,
+      (filePath) => /\/src\/.+\/presentation\/screens\/.+Screen\.tsx$/i.test(filePath)
+    );
+    const navigatorFile = findImportFiles(
+      context.paths,
+      (filePath) => /\/src\/core\/presentation\/navigation\/RootNavigator\.tsx$/i.test(filePath)
+    )[0];
+    const routeNamesByComponent = parseNavigatorRoutes(context.helpers.readTextIfExists(navigatorFile) || "");
+    const findings = [];
+    const candidates = { screens: [], routes: [], actions: [], stacks: [] };
+    for (const filePath of screenFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const parsed = parseScreenFile(filePath, text, context.paths.repoRoot, routeNamesByComponent);
+      if (!parsed) continue;
+      findings.push({
+        kind: "react_native_screen",
+        file: relativeTo(context.paths.repoRoot, filePath),
+        screen_id: parsed.screen.id_hint
+      });
+      candidates.screens.push(parsed.screen);
+      candidates.routes.push(parsed.route);
+      candidates.actions.push(...parsed.actions);
+    }
+    if (candidates.screens.length > 0) {
+      candidates.stacks.push("react_native");
+    }
+    candidates.screens = dedupeCandidateRecords(candidates.screens, (record) => record.id_hint);
+    candidates.routes = dedupeCandidateRecords(candidates.routes, (record) => record.id_hint);
+    candidates.actions = dedupeCandidateRecords(candidates.actions, (record) => record.id_hint);
+    candidates.stacks = [...new Set(candidates.stacks)].sort();
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/ui/react-router.js

@@ -0,0 +1,139 @@
+import {
+  dedupeCandidateRecords,
+  detectUiPresentationFeatures,
+  entityIdForRoute,
+  inferNavigationStructure,
+  inferReactRoutes,
+  makeCandidateRecord,
+  navigationPatternsFromStructure,
+  relativeTo,
+  shellKindFromNavigation,
+  screenIdForRoute,
+  screenKindForRoute,
+  uiCapabilityHintsForRoute,
+  titleCase,
+  idHintify
+} from "../../core/shared.js";
+import path from "node:path";
+
+export const reactRouterUiExtractor = {
+  id: "ui.react-router",
+  track: "ui",
+  detect(context) {
+    const roots = [
+      path.join(context.paths.workspaceRoot, "apps", "web"),
+      path.join(context.paths.workspaceRoot, "examples", "maintained", "proof-app")
+    ];
+    const count = roots.reduce((total, rootDir) => total + inferReactRoutes(rootDir, context.helpers).length, 0);
+    return { score: count > 0 ? 70 : 0, reasons: count > 0 ? ["Found React Router UI routes"] : [] };
+  },
+  extract(context) {
+    const findings = [];
+    const candidates = { screens: [], routes: [], actions: [], stacks: [] };
+    const roots = [
+      path.join(context.paths.workspaceRoot, "apps", "web"),
+      path.join(context.paths.workspaceRoot, "examples", "maintained", "proof-app")
+    ];
+    for (const rootDir of roots) {
+      const routes = inferReactRoutes(rootDir, context.helpers);
+      if (routes.length === 0) continue;
+      const provenance = relativeTo(context.paths.repoRoot, path.join(rootDir, "src", "App.tsx"));
+      const navigation = inferNavigationStructure(rootDir);
+      const features = detectUiPresentationFeatures(rootDir);
+      const shellKind = shellKindFromNavigation(navigation);
+      const navigationPatterns = navigationPatternsFromStructure(navigation);
+      findings.push({ kind: "react_ui_routes", file: provenance, routes });
+      findings.push({ kind: "react_ui_navigation", file: provenance, navigation });
+      findings.push({ kind: "react_ui_features", file: provenance, features });
+      candidates.stacks.push("react_web");
+      if (shellKind) {
+        candidates.actions.push(makeCandidateRecord({
+          kind: "ui_shell",
+          idHint: `${path.basename(rootDir)}_shell`,
+          label: titleCase(shellKind),
+          confidence: "medium",
+          sourceKind: "layout_code",
+          provenance,
+          track: "ui",
+          shell_kind: shellKind,
+          has_breadcrumbs: navigation.hasBreadcrumbs,
+          has_tabs: navigation.hasTabs
+        }));
+      }
+      for (const pattern of navigationPatterns) {
+        candidates.actions.push(makeCandidateRecord({
+          kind: "ui_navigation",
+          idHint: `${path.basename(rootDir)}_${idHintify(pattern)}`,
+          label: pattern,
+          confidence: "medium",
+          sourceKind: "layout_code",
+          provenance,
+          track: "ui",
+          navigation_pattern: pattern
+        }));
+      }
+      for (const routePath of routes) {
+        const screenId = screenIdForRoute(routePath);
+        const screenKind = screenKindForRoute(routePath);
+        const capabilityHints = uiCapabilityHintsForRoute(routePath);
+        candidates.screens.push(makeCandidateRecord({
+          kind: "screen",
+          idHint: screenId,
+          label: titleCase(screenId),
+          confidence: "medium",
+          sourceKind: "route_code",
+          provenance: `${provenance}#${routePath}`,
+          track: "ui",
+          entity_id: entityIdForRoute(routePath),
+          screen_kind: screenKind,
+          route_path: routePath,
+          capability_hints: capabilityHints
+        }));
+        candidates.routes.push(makeCandidateRecord({
+          kind: "ui_route",
+          idHint: `${screenId}_route`,
+          label: routePath,
+          confidence: "medium",
+          sourceKind: "route_code",
+          provenance: `${provenance}#${routePath}`,
+          track: "ui",
+          screen_id: screenId,
+          entity_id: entityIdForRoute(routePath),
+          path: routePath
+        }));
+        if (capabilityHints.primary_action) {
+          candidates.actions.push(makeCandidateRecord({
+            kind: "ui_action",
+            idHint: `${screenId}_${idHintify(capabilityHints.primary_action)}`,
+            label: capabilityHints.primary_action,
+            confidence: "low",
+            sourceKind: "route_code",
+            provenance: `${provenance}#${routePath}`,
+            track: "ui",
+            screen_id: screenId,
+            entity_id: entityIdForRoute(routePath),
+            capability_hint: capabilityHints.primary_action,
+            prominence: screenKind === "list" ? "primary" : "secondary"
+          }));
+        }
+      }
+      for (const feature of features) {
+        candidates.actions.push(makeCandidateRecord({
+          kind: "ui_presentation",
+          idHint: `${path.basename(rootDir)}_${idHintify(feature)}`,
+          label: feature,
+          confidence: "low",
+          sourceKind: "layout_code",
+          provenance,
+          track: "ui",
+          presentation: feature
+        }));
+      }
+    }
+    candidates.screens = dedupeCandidateRecords(candidates.screens, (record) => record.id_hint);
+    candidates.routes = dedupeCandidateRecords(candidates.routes, (record) => record.id_hint);
+    candidates.actions = dedupeCandidateRecords(candidates.actions, (record) => record.id_hint);
+    candidates.stacks = [...new Set(candidates.stacks)].sort();
+    return { findings, candidates };
+  }
+};