@topogram/cli 0.3.34

package/src/import/extractors/db/sql.js

@@ -0,0 +1,180 @@
+import { canonicalCandidateTerm, findImportFiles, makeCandidateRecord, relativeTo, selectPreferredImportFiles, slugify, titleCase, idHintify } from "../../core/shared.js";
+
+function parseTableConstraint(line, tableName) {
+  const normalized = line.replace(/,$/, "").trim();
+  const relationMatch = normalized.match(/foreign\s+key\s*\(([^)]+)\)\s+references\s+([A-Za-z0-9_".]+)\s*\(([^)]+)\)/i);
+  if (relationMatch) {
+    return {
+      type: "relation",
+      relation: {
+        from_entity: `entity_${canonicalCandidateTerm(tableName)}`,
+        to_entity: `entity_${canonicalCandidateTerm(relationMatch[2].split(".").pop().replace(/"/g, ""))}`,
+        relation_field: relationMatch[1].split(",")[0].trim().replace(/"/g, ""),
+        fields: relationMatch[1].split(",").map((entry) => entry.trim().replace(/"/g, "")),
+        references: relationMatch[3].split(",").map((entry) => entry.trim().replace(/"/g, ""))
+      }
+    };
+  }
+  return { type: "constraint" };
+}
+
+export function parseSqlSchema(sqlText) {
+  const entities = [];
+  const enums = [];
+  const relations = [];
+  const indexes = [];
+
+  for (const match of sqlText.matchAll(/create\s+type\s+([A-Za-z0-9_"]+)\s+as\s+enum\s*\(([\s\S]*?)\)\s*;/gi)) {
+    const [, rawName, rawValues] = match;
+    const enumName = rawName.replace(/"/g, "");
+    const values = rawValues
+      .split(",")
+      .map((value) => value.trim().replace(/^'+|'+$/g, ""))
+      .filter(Boolean);
+    enums.push({ name: enumName, values });
+  }
+
+  for (const match of sqlText.matchAll(/create\s+table\s+([A-Za-z0-9_".]+)\s*\(([\s\S]*?)\)\s*;/gi)) {
+    const [, rawName, body] = match;
+    const tableName = rawName.split(".").pop().replace(/"/g, "");
+    const entityStem = canonicalCandidateTerm(tableName);
+    const fields = [];
+    const bodyLines = body
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    for (const line of bodyLines) {
+      if (/^(constraint\b.*)?foreign\s+key\b/i.test(line) || /^primary\s+key\b/i.test(line) || /^unique\b/i.test(line) || /^check\b/i.test(line)) {
+        const parsedConstraint = parseTableConstraint(line, tableName);
+        if (parsedConstraint.type === "relation") {
+          relations.push(parsedConstraint.relation);
+        }
+        continue;
+      }
+      const columnMatch = line.replace(/,$/, "").match(/^"?(?<name>[A-Za-z0-9_]+)"?\s+(?<type>[A-Za-z0-9_()[\]".]+)(?<rest>.*)$/i);
+      if (!columnMatch) {
+        continue;
+      }
+      const name = columnMatch.groups.name;
+      const fieldType = columnMatch.groups.type.replace(/"/g, "");
+      const rest = columnMatch.groups.rest || "";
+      fields.push({
+        name,
+        field_type: fieldType,
+        required: /\bnot\s+null\b/i.test(rest) || /\bprimary\s+key\b/i.test(rest),
+        list: /\[\]$/.test(fieldType),
+        unique: /\bunique\b/i.test(rest),
+        primary_key: /\bprimary\s+key\b/i.test(rest)
+      });
+      const inlineReferenceMatch = rest.match(/\breferences\s+([A-Za-z0-9_".]+)\s*\(([^)]+)\)/i);
+      if (inlineReferenceMatch) {
+        relations.push({
+          from_entity: `entity_${entityStem}`,
+          to_entity: `entity_${canonicalCandidateTerm(inlineReferenceMatch[1].split(".").pop().replace(/"/g, ""))}`,
+          relation_field: name,
+          fields: [name],
+          references: inlineReferenceMatch[2].split(",").map((entry) => entry.trim().replace(/"/g, ""))
+        });
+      }
+    }
+
+    entities.push({
+      name: entityStem,
+      table_name: tableName,
+      fields
+    });
+  }
+
+  for (const match of sqlText.matchAll(/create\s+(unique\s+)?index\s+([A-Za-z0-9_"]+)\s+on\s+([A-Za-z0-9_".]+)\s*\(([^)]+)\)/gi)) {
+    const [, uniqueFlag, rawIndexName, rawTableName, rawFields] = match;
+    const tableName = rawTableName.split(".").pop().replace(/"/g, "");
+    indexes.push({
+      id_hint: idHintify(rawIndexName.replace(/"/g, "")),
+      entity: `entity_${canonicalCandidateTerm(tableName)}`,
+      fields: rawFields.split(",").map((entry) => entry.trim().replace(/"/g, "")),
+      unique: Boolean(uniqueFlag)
+    });
+  }
+
+  return { entities, enums, relations, indexes };
+}
+
+export const sqlExtractor = {
+  id: "db.sql",
+  track: "db",
+  detect(context) {
+    const files = findImportFiles(context.paths, (filePath) => filePath.endsWith(".sql"));
+    return {
+      score: files.length > 0 ? 80 : 0,
+      reasons: files.length > 0 ? ["Found SQL schema or migration files"] : []
+    };
+  },
+  extract(context) {
+    const allSqlFiles = findImportFiles(context.paths, (filePath) => filePath.endsWith(".sql"));
+    const schemaSqlFiles = allSqlFiles.filter((filePath) => !/migration/i.test(filePath) && !/\/src\/test\//i.test(filePath));
+    const migrationSqlFiles = allSqlFiles.filter((filePath) => /migration/i.test(filePath));
+    const sqlFiles =
+      schemaSqlFiles.length > 0
+        ? selectPreferredImportFiles(context.paths, schemaSqlFiles, "sql")
+        : selectPreferredImportFiles(context.paths, migrationSqlFiles, "sql");
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    for (const filePath of sqlFiles) {
+      const parsed = parseSqlSchema(context.helpers.readTextIfExists(filePath) || "");
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const sourceKind = /migration/i.test(filePath) ? "migration" : "schema";
+      const confidence = sourceKind === "migration" ? "medium" : "high";
+      findings.push({
+        kind: "sql_schema",
+        file: provenance,
+        entity_count: parsed.entities.length,
+        enum_count: parsed.enums.length
+      });
+      candidates.entities.push(...parsed.entities.map((entity) => makeCandidateRecord({
+        kind: "entity",
+        idHint: `entity_${slugify(entity.name)}`,
+        label: titleCase(entity.name),
+        confidence,
+        sourceKind,
+        provenance,
+        table_name: entity.table_name || slugify(entity.name),
+        fields: entity.fields,
+        track: "db"
+      })));
+      candidates.enums.push(...parsed.enums.map((entry) => makeCandidateRecord({
+        kind: "enum",
+        idHint: idHintify(entry.name),
+        label: titleCase(entry.name),
+        confidence,
+        sourceKind,
+        provenance,
+        values: entry.values,
+        track: "db"
+      })));
+      candidates.relations.push(...parsed.relations.map((relation) => makeCandidateRecord({
+        kind: "relation",
+        idHint: slugify(`${relation.from_entity}_${relation.relation_field}_${relation.to_entity}`),
+        label: `${relation.from_entity} -> ${relation.to_entity}`,
+        confidence: "medium",
+        sourceKind,
+        provenance,
+        ...relation,
+        track: "db"
+      })));
+      candidates.indexes.push(...parsed.indexes.map((index) => makeCandidateRecord({
+        kind: "index",
+        idHint: index.id_hint,
+        label: titleCase(index.id_hint.replace(/^index_/, "")),
+        confidence: "medium",
+        sourceKind,
+        provenance,
+        entity: index.entity,
+        fields: index.fields,
+        unique: index.unique,
+        track: "db"
+      })));
+    }
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/db/swiftdata.js

@@ -0,0 +1,137 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function swiftFieldType(typeName) {
+  const normalized = String(typeName || "").replace(/\?$/, "").trim();
+  switch (normalized) {
+    case "String": return "string";
+    case "Int": return "int";
+    case "Double": return "double";
+    case "Float": return "float";
+    case "Bool": return "boolean";
+    case "URL": return "url";
+    default:
+      if (/^\[.+\]$/.test(normalized)) return "json";
+      return idHintify(normalized) || "string";
+  }
+}
+
+function parseSwiftModelBlocks(text) {
+  const blocks = [];
+  const pattern = /@Model\s+final\s+class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([\s\S]*?)\n\}/g;
+  for (const match of String(text || "").matchAll(pattern)) {
+    blocks.push({ className: match[1], body: match[2] });
+  }
+  return blocks;
+}
+
+function parseSwiftDataEntity(block, provenance) {
+  const stem = idHintify(canonicalCandidateTerm(block.className.replace(/([a-z0-9])([A-Z])/g, "$1_$2")));
+  const fields = [];
+  const relations = [];
+  let uniqueNext = false;
+  let relationNext = false;
+
+  for (const rawLine of String(block.body || "").split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("@Attribute(.unique)")) {
+      uniqueNext = true;
+      continue;
+    }
+    if (line.startsWith("@Relationship")) {
+      relationNext = true;
+      continue;
+    }
+    const match = line.match(/^var\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^=]+)/);
+    if (!match) continue;
+    const [, name, rawType] = match;
+    const typeName = rawType.trim();
+    const isList = /^\[.+\]\??$/.test(typeName);
+    const innerType = isList ? typeName.replace(/^\[/, "").replace(/\]\??$/, "") : typeName.replace(/\?$/, "");
+    const looksRelation = relationNext || /^[A-Z][A-Za-z0-9_]+$/.test(innerType);
+    fields.push({
+      name,
+      field_type: looksRelation ? idHintify(innerType.replace(/([a-z0-9])([A-Z])/g, "$1_$2")) : swiftFieldType(typeName),
+      required: !typeName.includes("?"),
+      list: isList,
+      unique: uniqueNext,
+      primary_key: false
+    });
+    if (looksRelation) {
+      relations.push(makeCandidateRecord({
+        kind: "relation",
+        idHint: `${stem}_${name}_${idHintify(innerType)}`,
+        label: `${stem} -> ${innerType}`,
+        confidence: "medium",
+        sourceKind: "schema",
+        provenance,
+        from_entity: `entity_${stem}`,
+        to_entity: `entity_${canonicalCandidateTerm(idHintify(innerType.replace(/([a-z0-9])([A-Z])/g, "$1_$2")))}`,
+        relation_field: name,
+        fields: [name],
+        references: ["id"],
+        relation_type: isList ? "many" : "one",
+        track: "db"
+      }));
+    }
+    uniqueNext = false;
+    relationNext = false;
+  }
+
+  return {
+    entity: makeCandidateRecord({
+      kind: "entity",
+      idHint: `entity_${stem}`,
+      label: titleCase(stem),
+      confidence: "high",
+      sourceKind: "schema",
+      provenance,
+      model_name: block.className,
+      fields,
+      track: "db"
+    }),
+    relations
+  };
+}
+
+export const swiftDataExtractor = {
+  id: "db.swiftdata",
+  track: "db",
+  detect(context) {
+    const files = findImportFiles(context.paths, (filePath) => /\.swift$/i.test(filePath))
+      .filter((filePath) => /@Model/.test(context.helpers.readTextIfExists(filePath) || ""));
+    return {
+      score: files.length > 0 ? 86 : 0,
+      reasons: files.length > 0 ? ["Found SwiftData @Model classes"] : []
+    };
+  },
+  extract(context) {
+    const files = findImportFiles(context.paths, (filePath) => /\.swift$/i.test(filePath))
+      .filter((filePath) => /@Model/.test(context.helpers.readTextIfExists(filePath) || ""));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    for (const filePath of files) {
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const blocks = parseSwiftModelBlocks(context.helpers.readTextIfExists(filePath) || "");
+      for (const block of blocks) {
+        const parsed = parseSwiftDataEntity(block, provenance);
+        candidates.entities.push(parsed.entity);
+        candidates.relations.push(...parsed.relations);
+      }
+      if (blocks.length > 0) {
+        findings.push({ kind: "swiftdata_models", file: provenance, entity_count: blocks.length });
+      }
+    }
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    candidates.relations = dedupeCandidateRecords(candidates.relations, (record) => record.id_hint);
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/ui/android-compose.js

@@ -0,0 +1,230 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function screenKindFromId(id) {
+  if (/detail/i.test(id)) return "detail";
+  if (/settings/i.test(id)) return "settings";
+  if (/home|list/i.test(id)) return "list";
+  return "flow";
+}
+
+function entityIdFromScreenId(id) {
+  if (/pokemon/i.test(id) || /home|detail/i.test(id)) return "entity_pokemon";
+  if (/settings/i.test(id)) return null;
+  return `entity_${canonicalCandidateTerm(id)}`;
+}
+
+function parseNavHostEntries(text) {
+  const entries = [];
+  for (const match of String(text || "").matchAll(/entry<[^>]*?\.([A-Za-z_][A-Za-z0-9_]*)>\s*(?:\([\s\S]*?\))?\s*\{[\s\S]*?\b([A-Z][A-Za-z0-9_]*)\s*\(/g)) {
+    entries.push({
+      navKey: match[1],
+      composable: match[2]
+    });
+  }
+  return entries;
+}
+
+function parseNavigationActions(text) {
+  const actions = [];
+  for (const match of String(text || "").matchAll(/navigate(?:To)?\(?\s*(?:PokedexScreen\.)?([A-Z][A-Za-z0-9_]+)/g)) {
+    actions.push(match[1]);
+  }
+  return [...new Set(actions)];
+}
+
+function composeNavigationSummary(text) {
+  const source = String(text || "");
+  return {
+    shellKind:
+      /\bNavigationRail\b/.test(source) ? "sidebar"
+      : /\bNavigationBar\b/.test(source) ? "bottom_tabs"
+      : /\bScaffold\b|\bTopAppBar\b/.test(source) ? "topbar"
+      : null,
+    patterns: [
+      ...new Set([
+        /\bNavHost\b|\bNavController\b/.test(source) ? "stack_navigation" : null,
+        /\bNavigationBar\b/.test(source) ? "bottom_tabs" : null,
+        /\bNavigationRail\b/.test(source) ? "navigation_rail" : null,
+        /\bTabRow\b|\bScrollableTabRow\b|\bHorizontalPager\b/.test(source) ? "tabs" : null
+      ].filter(Boolean))
+    ],
+    features: [
+      ...new Set([
+        /\bModalBottomSheet\b|\bBottomSheetScaffold\b/.test(source) ? "sheet" : null,
+        /\bModalBottomSheet\b|\bBottomSheetScaffold\b/.test(source) ? "bottom_sheet" : null,
+        /\bFloatingActionButton\b|\bExtendedFloatingActionButton\b/.test(source) ? "fab" : null,
+        /\bpullRefresh\b|\bPullRefreshIndicator\b/.test(source) ? "pull_to_refresh" : null,
+        /\bSearchBar\b|\bSearchView\b/.test(source) ? "search" : null
+      ].filter(Boolean))
+    ]
+  };
+}
+
+function mergeComposeSummaries(summaries) {
+  const shellKind =
+    summaries.find((entry) => entry.shellKind === "sidebar")?.shellKind
+    || summaries.find((entry) => entry.shellKind === "bottom_tabs")?.shellKind
+    || summaries.find((entry) => entry.shellKind === "topbar")?.shellKind
+    || null;
+  return {
+    shellKind,
+    patterns: [...new Set(summaries.flatMap((entry) => entry.patterns || []))].sort(),
+    features: [...new Set(summaries.flatMap((entry) => entry.features || []))].sort()
+  };
+}
+
+export const androidComposeUiExtractor = {
+  id: "ui.android-compose",
+  track: "ui",
+  detect(context) {
+    const composeFiles = findImportFiles(context.paths, (filePath) => /\.kt$/i.test(filePath))
+      .filter((filePath) => /@Composable/.test(context.helpers.readTextIfExists(filePath) || ""));
+    const score = composeFiles.length > 0 ? 84 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found Android Jetpack Compose screens"] : []
+    };
+  },
+  extract(context) {
+    const navFiles = findImportFiles(context.paths, (filePath) => /NavHost\.kt$/i.test(filePath) || /navigation\/.+\.kt$/i.test(filePath));
+    const composeFiles = findImportFiles(context.paths, (filePath) => /\.kt$/i.test(filePath))
+      .filter((filePath) => /@Composable/.test(context.helpers.readTextIfExists(filePath) || ""));
+    const findings = [];
+    const candidates = { screens: [], routes: [], actions: [], stacks: [] };
+    const composableByName = new Map();
+    const composeSummaries = [];
+
+    for (const filePath of composeFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      composeSummaries.push({
+        provenance: relativeTo(context.paths.repoRoot, filePath),
+        ...composeNavigationSummary(text)
+      });
+      for (const match of text.matchAll(/@Composable[\s\S]*?fun\s+([A-Z][A-Za-z0-9_]*)\s*\(/g)) {
+        composableByName.set(match[1], {
+          filePath,
+          text
+        });
+      }
+    }
+
+    const aggregateSummary = mergeComposeSummaries(composeSummaries);
+    if (aggregateSummary.shellKind) {
+      candidates.actions.push(makeCandidateRecord({
+        kind: "ui_shell",
+        idHint: `${idHintify(aggregateSummary.shellKind)}_shell`,
+        label: titleCase(aggregateSummary.shellKind),
+        confidence: "medium",
+        sourceKind: "layout_code",
+        provenance: composeSummaries.map((entry) => entry.provenance),
+        track: "ui",
+        shell_kind: aggregateSummary.shellKind
+      }));
+    }
+    for (const pattern of aggregateSummary.patterns) {
+      candidates.actions.push(makeCandidateRecord({
+        kind: "ui_navigation",
+        idHint: `compose_${idHintify(pattern)}`,
+        label: pattern,
+        confidence: "medium",
+        sourceKind: "layout_code",
+        provenance: composeSummaries.filter((entry) => entry.patterns.includes(pattern)).map((entry) => entry.provenance),
+        track: "ui",
+        navigation_pattern: pattern
+      }));
+    }
+    for (const feature of aggregateSummary.features) {
+      candidates.actions.push(makeCandidateRecord({
+        kind: "ui_presentation",
+        idHint: `compose_${idHintify(feature)}`,
+        label: feature,
+        confidence: "low",
+        sourceKind: "layout_code",
+        provenance: composeSummaries.filter((entry) => entry.features.includes(feature)).map((entry) => entry.provenance),
+        track: "ui",
+        presentation: feature
+      }));
+    }
+
+    for (const filePath of navFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const provenanceFile = relativeTo(context.paths.repoRoot, filePath);
+      for (const entry of parseNavHostEntries(text)) {
+        const screenStem = canonicalCandidateTerm(entry.navKey.replace(/Screen$/, ""));
+        const screenId = /details/i.test(entry.navKey) ? "pokemon_detail" : /home/i.test(entry.navKey) ? "pokemon_list" : /settings/i.test(entry.navKey) ? "settings" : idHintify(screenStem);
+        const routePath = /detail/i.test(screenId) ? "/pokemon/:name" : screenId === "pokemon_list" ? "/pokemon" : screenId === "settings" ? "/settings" : `/${screenStem.replace(/_/g, "-")}`;
+        const entityId = entityIdFromScreenId(screenId);
+        candidates.screens.push(makeCandidateRecord({
+          kind: "screen",
+          idHint: screenId,
+          label: titleCase(screenId),
+          confidence: "high",
+          sourceKind: "route_code",
+          provenance: `${provenanceFile}#${entry.navKey}`,
+          track: "ui",
+          entity_id: entityId,
+          concept_id: entityId || `surface_${screenId}`,
+          screen_kind: screenKindFromId(screenId),
+          route_path: routePath
+        }));
+        candidates.routes.push(makeCandidateRecord({
+          kind: "ui_route",
+          idHint: `${screenId}_route`,
+          label: routePath,
+          confidence: "high",
+          sourceKind: "route_code",
+          provenance: `${provenanceFile}#${entry.navKey}`,
+          track: "ui",
+          screen_id: screenId,
+          entity_id: entityId,
+          concept_id: entityId || `surface_${screenId}`,
+          path: routePath
+        }));
+
+        const screenFile = composableByName.get(entry.composable);
+        const actions = parseNavigationActions(screenFile?.text || "");
+        for (const action of actions) {
+          const capabilityHint = /detail/i.test(action) ? "cap_get_pokemon" : /settings/i.test(action) ? null : "cap_list_pokemons";
+          if (!capabilityHint) continue;
+          candidates.actions.push(makeCandidateRecord({
+            kind: "ui_action",
+            idHint: `${screenId}_${idHintify(capabilityHint)}`,
+            label: capabilityHint,
+            confidence: "medium",
+            sourceKind: "route_code",
+            provenance: `${relativeTo(context.paths.repoRoot, screenFile?.filePath || filePath)}#${entry.composable}`,
+            track: "ui",
+            screen_id: screenId,
+            entity_id: entityId,
+            concept_id: entityId || `surface_${screenId}`,
+            capability_hint: capabilityHint,
+            prominence: "primary"
+          }));
+        }
+      }
+    }
+
+    if (candidates.screens.length > 0) {
+      findings.push({
+        kind: "android_compose_navigation",
+        screen_count: candidates.screens.length,
+        route_count: candidates.routes.length
+      });
+      candidates.stacks.push("android_compose");
+    }
+
+    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/backend-only.js

@@ -0,0 +1,70 @@
+import path from "node:path";
+
+import { findImportFiles, relativeTo } from "../../core/shared.js";
+
+function readPackageJson(context) {
+  const packageFile = findImportFiles(context.paths, (filePath) => /package\.json$/i.test(filePath))[0];
+  if (!packageFile) return null;
+  try {
+    return {
+      filePath: packageFile,
+      json: JSON.parse(context.helpers.readTextIfExists(packageFile) || "{}")
+    };
+  } catch {
+    return null;
+  }
+}
+
+function hasFrontendSignals(context) {
+  const packageMeta = readPackageJson(context);
+  const deps = {
+    ...(packageMeta?.json?.dependencies || {}),
+    ...(packageMeta?.json?.devDependencies || {})
+  };
+  if (deps.react || deps.next || deps["@remix-run/react"] || deps["@sveltejs/kit"] || deps.svelte || deps.vue || deps.nuxt) {
+    return true;
+  }
+  const uiFiles = findImportFiles(
+    context.paths,
+    (filePath) =>
+      /(app\/.+\/page\.(tsx|ts|jsx|js|mdx)|src\/App\.tsx|src\/routes\/.+\.(svelte|tsx|jsx)|pages\/.+\.(tsx|ts|jsx|js))$/i.test(filePath)
+  );
+  return uiFiles.length > 0;
+}
+
+export const backendOnlyUiExtractor = {
+  id: "ui.backend-only",
+  track: "ui",
+  detect(context) {
+    const packageMeta = readPackageJson(context);
+    if (!packageMeta || hasFrontendSignals(context)) {
+      return { score: 0, reasons: [] };
+    }
+    const deps = {
+      ...(packageMeta.json.dependencies || {}),
+      ...(packageMeta.json.devDependencies || {})
+    };
+    const isBackend = deps.express || deps.fastify || deps.hono || deps["@nestjs/core"];
+    return {
+      score: isBackend ? 5 : 0,
+      reasons: isBackend ? ["Detected backend-only project with no supported frontend stack"] : []
+    };
+  },
+  extract(context) {
+    const packageMeta = readPackageJson(context);
+    const provenance = packageMeta ? relativeTo(context.paths.repoRoot, packageMeta.filePath) : relativeTo(context.paths.repoRoot, path.join(context.paths.workspaceRoot, "package.json"));
+    return {
+      findings: [{
+        kind: "backend_only_project",
+        file: provenance,
+        message: "No supported frontend stack detected in this workspace"
+      }],
+      candidates: {
+        screens: [],
+        routes: [],
+        actions: [],
+        stacks: ["backend_only"]
+      }
+    };
+  }
+};