@topogram/cli 0.3.34

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

@@ -0,0 +1,120 @@
+import { canonicalCandidateTerm, dedupeCandidateRecords, findImportFiles, makeCandidateRecord, relativeTo, slugify, titleCase } from "../../core/shared.js";
+
+function extractAnnotatedFields(text) {
+  const fields = [];
+  const relations = [];
+  const enumFields = [];
+  for (const match of String(text || "").matchAll(/((?:\s*@[\w.]+(?:\([^)]*\))?\s*)+)\s*private\s+([A-Za-z0-9_<>\[\]\.?]+)\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/g)) {
+    const [, annotations, rawType, name] = match;
+    const baseType = rawType.replace(/^Set<|^List</, "").replace(/>$/, "").split(".").pop();
+    const columnName = annotations.match(/@JoinColumn\(name\s*=\s*"([^"]+)"/)?.[1] || annotations.match(/@Column\(name\s*=\s*"([^"]+)"/)?.[1] || name;
+    const isRelation = /@(ManyToOne|OneToOne|OneToMany|ManyToMany)/.test(annotations);
+    if (isRelation) {
+      const relationTarget = canonicalCandidateTerm(baseType.replace(/Data$/, ""));
+      relations.push({
+        to_entity: `entity_${slugify(relationTarget)}`,
+        relation_field: columnName,
+        fields: [columnName],
+        references: ["id"]
+      });
+      if (/@(OneToMany|ManyToMany)/.test(annotations)) {
+        continue;
+      }
+    }
+    if (/@Enumerated/.test(annotations)) {
+      enumFields.push({ name: columnName, enum_name: baseType });
+    }
+    fields.push({
+      name: columnName,
+      field_type: rawType.toLowerCase(),
+      required: /nullable\s*=\s*false/.test(annotations) || /@Id\b/.test(annotations),
+      list: /^Set<|^List</.test(rawType),
+      unique: /unique\s*=\s*true/.test(annotations),
+      primary_key: /@Id\b/.test(annotations)
+    });
+  }
+  return { fields, relations, enumFields };
+}
+
+function isNoiseEntity(entityStem) {
+  return ["order-item", "orderitem"].includes(entityStem) || /(?:favorite|follow|tag)-?relationship$/.test(entityStem);
+}
+
+export const jpaExtractor = {
+  id: "db.jpa",
+  track: "db",
+  detect(context) {
+    const entityFiles = findImportFiles(context.paths, (filePath) => /\.java$/i.test(filePath));
+    const count = entityFiles.filter((filePath) => /@Entity\b/.test(context.helpers.readTextIfExists(filePath) || "")).length;
+    return {
+      score: count > 0 ? 87 : 0,
+      reasons: count > 0 ? ["Found JPA @Entity classes"] : []
+    };
+  },
+  extract(context) {
+    const files = findImportFiles(context.paths, (filePath) => /\.java$/i.test(filePath));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+
+    for (const filePath of files) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const entityName = text.match(/@Entity(?:\(name\s*=\s*"([^"]+)"\))?/)?.[1];
+      if (!/@Entity\b/.test(text)) continue;
+      const className = text.match(/class\s+([A-Za-z_][A-Za-z0-9_]*)/)?.[1] || "";
+      const tableName = text.match(/@Table\(name\s*=\s*"([^"]+)"\)/)?.[1] || entityName || className;
+      const entityStem = canonicalCandidateTerm(String(entityName || tableName || className).replace(/Data$/, ""));
+      const { fields, relations, enumFields } = extractAnnotatedFields(text);
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const noiseCandidate = isNoiseEntity(entityStem);
+
+      findings.push({
+        kind: "jpa_entity",
+        file: provenance,
+        entity: entityStem,
+        field_count: fields.length
+      });
+
+      candidates.entities.push(makeCandidateRecord({
+        kind: "entity",
+        idHint: `entity_${slugify(entityStem)}`,
+        label: titleCase(entityStem),
+        confidence: "high",
+        sourceKind: "schema",
+        provenance,
+        table_name: tableName,
+        fields,
+        noise_candidate: noiseCandidate,
+        noise_reason: noiseCandidate ? "JPA implementation-noise child entity." : null,
+        track: "db"
+      }));
+
+      candidates.relations.push(...relations.map((relation) => makeCandidateRecord({
+        kind: "relation",
+        idHint: slugify(`entity_${entityStem}_${relation.relation_field}_${relation.to_entity}`),
+        label: `entity_${entityStem} -> ${relation.to_entity}`,
+        confidence: "high",
+        sourceKind: "schema",
+        provenance,
+        from_entity: `entity_${slugify(entityStem)}`,
+        ...relation,
+        track: "db"
+      })));
+
+      candidates.enums.push(...enumFields.map((entry) => makeCandidateRecord({
+        kind: "enum",
+        idHint: slugify(entry.enum_name),
+        label: titleCase(entry.enum_name),
+        confidence: "medium",
+        sourceKind: "schema",
+        provenance,
+        values: [],
+        track: "db"
+      })));
+    }
+
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    candidates.relations = dedupeCandidateRecords(candidates.relations, (record) => record.id_hint);
+    candidates.enums = dedupeCandidateRecords(candidates.enums, (record) => record.id_hint);
+    return { findings, candidates };
+  }
+};

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

@@ -0,0 +1,180 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  slugify,
+  titleCase
+} from "../../core/shared.js";
+
+function normalizeLiquibaseTableName(tableName) {
+  return String(tableName || "")
+    .replace(/^(tbl?|v)_/i, "")
+    .replace(/_/g, "-");
+}
+
+function isJoinTable(tableName, fields) {
+  const normalized = normalizeLiquibaseTableName(tableName);
+  const idFields = (fields || []).filter((field) => field.name.endsWith("_id"));
+  return (
+    ["article-tags", "favorites", "follows"].includes(normalized) ||
+    (idFields.length >= 2 && (fields || []).length <= 4)
+  );
+}
+
+function joinNoiseReason(tableName) {
+  const normalized = normalizeLiquibaseTableName(tableName);
+  if (normalized === "article-tags") return "Liquibase implementation-noise join table for article-tag linkage.";
+  if (normalized === "favorites" || normalized === "article-favorites") return "Liquibase implementation-noise join table for article favorites.";
+  if (normalized === "follows" || normalized === "follow-relation") return "Liquibase implementation-noise join table for follow relationships.";
+  return "Liquibase implementation-noise join table.";
+}
+
+function parseConstraints(raw) {
+  return {
+    required: /nullable="false"/.test(raw),
+    unique: /unique="true"/.test(raw),
+    primary_key: /primaryKey="true"/.test(raw),
+    referencedTableName: raw.match(/referencedTableName="([^"]+)"/)?.[1] || null,
+    referencedColumnNames: raw.match(/referencedColumnNames="([^"]+)"/)?.[1] || null
+  };
+}
+
+function parseLiquibaseSchema(xmlText) {
+  const entities = [];
+  const relations = [];
+  const indexes = [];
+
+  for (const match of String(xmlText || "").matchAll(/<createTable\s+tableName="([^"]+)"[^>]*>([\s\S]*?)<\/createTable>/g)) {
+    const [, tableName, tableBody] = match;
+    if (/^v_/i.test(tableName)) continue;
+    const entityStem = canonicalCandidateTerm(normalizeLiquibaseTableName(tableName));
+    const fields = [];
+
+    for (const columnMatch of tableBody.matchAll(/<column\s+name="([^"]+)"\s+type="([^"]+)"[^>]*>([\s\S]*?)<\/column>|<column\s+name="([^"]+)"\s+type="([^"]+)"([^>]*)\/>/g)) {
+      const name = columnMatch[1] || columnMatch[4];
+      const fieldType = (columnMatch[2] || columnMatch[5] || "").toLowerCase();
+      const inner = columnMatch[3] || columnMatch[6] || "";
+      const constraints = parseConstraints(inner);
+      fields.push({
+        name,
+        field_type: fieldType,
+        required: constraints.required,
+        unique: constraints.unique,
+        primary_key: constraints.primary_key,
+        list: false
+      });
+      if (constraints.referencedTableName) {
+        const targetStem = canonicalCandidateTerm(normalizeLiquibaseTableName(constraints.referencedTableName));
+        relations.push({
+          from_entity: `entity_${entityStem}`,
+          to_entity: `entity_${targetStem}`,
+          relation_field: name,
+          fields: [name],
+          references: String(constraints.referencedColumnNames || "id").split(/\s*,\s*/)
+        });
+      }
+    }
+
+    const noiseCandidate = isJoinTable(tableName, fields);
+    entities.push({
+      id_hint: `entity_${entityStem}`,
+      label: titleCase(entityStem),
+      table_name: tableName,
+      fields,
+      noise_candidate: noiseCandidate,
+      noise_reason: noiseCandidate ? joinNoiseReason(tableName) : null
+    });
+  }
+
+  for (const match of String(xmlText || "").matchAll(/<createIndex\s+indexName="([^"]+)"\s+tableName="([^"]+)"[^>]*>([\s\S]*?)<\/createIndex>/g)) {
+    const [, indexName, tableName, body] = match;
+    if (/^v_/i.test(tableName)) continue;
+    const entityStem = canonicalCandidateTerm(normalizeLiquibaseTableName(tableName));
+    const fields = [...body.matchAll(/<column\s+name="([^"]+)"\s*\/>/g)].map((entry) => entry[1]);
+    indexes.push({
+      id_hint: idHintify(indexName),
+      entity: `entity_${entityStem}`,
+      fields,
+      unique: false
+    });
+  }
+
+  return { entities, relations, indexes };
+}
+
+export const liquibaseExtractor = {
+  id: "db.liquibase",
+  track: "db",
+  detect(context) {
+    const files = findImportFiles(context.paths, (filePath) => /db\/changelog\/.+\.(xml|ya?ml)$/i.test(filePath));
+    return {
+      score: files.length > 0 ? 88 : 0,
+      reasons: files.length > 0 ? ["Found Liquibase changelog files"] : []
+    };
+  },
+  extract(context) {
+    const changelogFiles = findImportFiles(context.paths, (filePath) => /db\/changelog\/.+\.xml$/i.test(filePath));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+
+    for (const filePath of changelogFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const parsed = parseLiquibaseSchema(text);
+      if (parsed.entities.length === 0 && parsed.relations.length === 0) continue;
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+
+      findings.push({
+        kind: "liquibase_schema",
+        file: provenance,
+        entity_count: parsed.entities.length,
+        relation_count: parsed.relations.length
+      });
+
+      candidates.entities.push(...parsed.entities.map((entity) => makeCandidateRecord({
+        kind: "entity",
+        idHint: entity.id_hint,
+        label: entity.label,
+        confidence: "high",
+        sourceKind: "schema",
+        provenance,
+        table_name: entity.table_name,
+        fields: entity.fields,
+        noise_candidate: entity.noise_candidate,
+        noise_reason: entity.noise_reason,
+        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: "high",
+        sourceKind: "schema",
+        provenance,
+        ...relation,
+        track: "db"
+      })));
+
+      candidates.indexes.push(...parsed.indexes.map((index) => makeCandidateRecord({
+        kind: "index",
+        idHint: index.id_hint,
+        label: titleCase(index.id_hint.replace(/^ix_/, "")),
+        confidence: "medium",
+        sourceKind: "schema",
+        provenance,
+        entity: index.entity,
+        fields: index.fields,
+        unique: index.unique,
+        track: "db"
+      })));
+    }
+
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    candidates.relations = dedupeCandidateRecords(candidates.relations, (record) => record.id_hint);
+    candidates.indexes = dedupeCandidateRecords(candidates.indexes, (record) => record.id_hint);
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/db/mybatis-xml.js

@@ -0,0 +1,145 @@
+import { dedupeCandidateRecords, findImportFiles, makeCandidateRecord, relativeTo, selectPreferredImportFiles, slugify, titleCase, idHintify, canonicalCandidateTerm } from "../../core/shared.js";
+import { parseSqlSchema } from "./sql.js";
+
+function classifyNoiseEntity(tableName, fields) {
+  const normalized = String(tableName || "").toLowerCase();
+  const idLikeFields = (fields || []).filter((field) => /_id$/.test(field.name));
+  if (["article_favorites", "article_tags", "follows"].includes(normalized)) {
+    return {
+      noise_candidate: true,
+      noise_reason:
+        normalized === "article_favorites"
+          ? "Spring MyBatis implementation-noise join table for article favorites."
+          : normalized === "article_tags"
+            ? "Spring MyBatis implementation-noise join table for article-tag linkage."
+            : "Spring MyBatis implementation-noise join table for follow relationships."
+    };
+  }
+  if (idLikeFields.length >= 2 && (fields || []).length <= 4) {
+    return {
+      noise_candidate: true,
+      noise_reason: "Spring MyBatis implementation-noise join table."
+    };
+  }
+  return {
+    noise_candidate: false,
+    noise_reason: null
+  };
+}
+
+function isUsableMapperTableName(tableName) {
+  const normalized = String(tableName || "").trim().toLowerCase();
+  return normalized && !["id", "name", "count"].includes(normalized);
+}
+
+export const myBatisXmlExtractor = {
+  id: "db.mybatis-xml",
+  track: "db",
+  detect(context) {
+    const mapperFiles = findImportFiles(context.paths, (filePath) => /\/mapper\/.+\.xml$/i.test(filePath));
+    return {
+      score: mapperFiles.length > 0 ? 86 : 0,
+      reasons: mapperFiles.length > 0 ? ["Found MyBatis mapper XML files"] : []
+    };
+  },
+  extract(context) {
+    const mapperFiles = findImportFiles(context.paths, (filePath) => /\/mapper\/.+\.xml$/i.test(filePath));
+    const allSqlFiles = findImportFiles(context.paths, (filePath) => filePath.endsWith(".sql"));
+    const schemaSqlFiles = allSqlFiles.filter((filePath) => !/\/src\/test\//i.test(filePath));
+    const sqlFiles = selectPreferredImportFiles(context.paths, schemaSqlFiles, "sql");
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+
+    if (mapperFiles.length === 0) {
+      return { findings, candidates };
+    }
+
+    const seenTableNames = new Set();
+    for (const filePath of sqlFiles) {
+      const parsed = parseSqlSchema(context.helpers.readTextIfExists(filePath) || "");
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      findings.push({
+        kind: "mybatis_schema",
+        file: provenance,
+        entity_count: parsed.entities.length,
+        relation_count: parsed.relations.length
+      });
+
+      for (const entity of parsed.entities) {
+        const tableName = entity.table_name || entity.name;
+        seenTableNames.add(tableName);
+        const noise = classifyNoiseEntity(tableName, entity.fields);
+        candidates.entities.push(makeCandidateRecord({
+          kind: "entity",
+          idHint: `entity_${slugify(entity.name)}`,
+          label: titleCase(entity.name),
+          confidence: "high",
+          sourceKind: "schema",
+          provenance,
+          table_name: tableName,
+          fields: entity.fields,
+          noise_candidate: noise.noise_candidate,
+          noise_reason: noise.noise_reason,
+          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: "schema",
+        provenance,
+        ...relation,
+        track: "db"
+      })));
+
+      candidates.indexes.push(...parsed.indexes.map((index) => makeCandidateRecord({
+        kind: "index",
+        idHint: index.id_hint || idHintify(index.entity),
+        label: titleCase((index.id_hint || index.entity || "").replace(/^index_/, "")),
+        confidence: "medium",
+        sourceKind: "schema",
+        provenance,
+        entity: index.entity,
+        fields: index.fields,
+        unique: index.unique,
+        track: "db"
+      })));
+    }
+
+    for (const filePath of mapperFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const namespace = text.match(/<mapper\s+namespace="([^"]+)"/)?.[1] || "";
+      const mapperStem = namespace.split(".").pop()?.replace(/Mapper$|ReadService$/i, "") || filePath.split("/").pop()?.replace(/\.xml$/, "") || "";
+      const tableMatches = [...text.matchAll(/\b(?:from|into|update|join)\s+([a-z_][a-z0-9_]*)\b/gi)].map((entry) => entry[1]);
+      for (const tableName of tableMatches) {
+        if (!isUsableMapperTableName(tableName)) continue;
+        if (seenTableNames.has(tableName)) continue;
+        const stem = canonicalCandidateTerm(tableName);
+        const noise = classifyNoiseEntity(tableName, []);
+        candidates.entities.push(makeCandidateRecord({
+          kind: "entity",
+          idHint: `entity_${slugify(stem)}`,
+          label: titleCase(mapperStem || stem),
+          confidence: "medium",
+          sourceKind: "mapper_code",
+          provenance,
+          table_name: tableName,
+          fields: [],
+          noise_candidate: noise.noise_candidate,
+          noise_reason: noise.noise_reason,
+          track: "db"
+        }));
+        seenTableNames.add(tableName);
+      }
+    }
+
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    candidates.relations = dedupeCandidateRecords(candidates.relations, (record) => record.id_hint);
+    candidates.indexes = dedupeCandidateRecords(candidates.indexes, (record) => record.id_hint);
+    return { findings, candidates };
+  }
+};

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

@@ -0,0 +1,185 @@
+import {
+  findImportFiles,
+  makeCandidateRecord,
+  normalizePrismaType,
+  relativeTo,
+  selectPreferredImportFiles,
+  slugify,
+  titleCase,
+  idHintify
+} from "../../core/shared.js";
+
+function parsePrismaSchema(schemaText) {
+  const enums = [];
+  const entities = [];
+  const relations = [];
+  const indexes = [];
+  const enumNames = new Set();
+  const modelNames = [];
+
+  for (const match of schemaText.matchAll(/^enum\s+([A-Za-z0-9_]+)\s*\{([\s\S]*?)^\}/gm)) {
+    const [, enumName, body] = match;
+    const values = body
+      .split(/\r?\n/)
+      .map((line) => line.replace(/\/\/.*$/, "").trim())
+      .filter((line) => line && !line.startsWith("@@"))
+      .map((line) => line.split(/\s+/)[0]);
+    enumNames.add(enumName);
+    enums.push({ name: enumName, values });
+  }
+
+  for (const match of schemaText.matchAll(/^model\s+([A-Za-z0-9_]+)\s*\{/gm)) {
+    modelNames.push(match[1]);
+  }
+  const modelNameSet = new Set(modelNames);
+
+  for (const match of schemaText.matchAll(/^model\s+([A-Za-z0-9_]+)\s*\{([\s\S]*?)^\}/gm)) {
+    const [, modelName, body] = match;
+    const fields = [];
+    const localIndexes = [];
+    const lines = body
+      .split(/\r?\n/)
+      .map((line) => line.replace(/\/\/.*$/, "").trim())
+      .filter(Boolean);
+
+    for (const line of lines) {
+      if (line.startsWith("@@")) {
+        const indexMatch = line.match(/^@@(unique|index)\(\[([^\]]+)\]/);
+        if (indexMatch) {
+          const [, type, rawFields] = indexMatch;
+          localIndexes.push({
+            id_hint: `index_${slugify(`${modelName}_${rawFields}`)}`,
+            fields: rawFields.split(",").map((field) => field.trim()),
+            unique: type === "unique"
+          });
+        }
+        continue;
+      }
+
+      const fieldMatch = line.match(/^([A-Za-z0-9_]+)\s+([^\s]+)(.*)$/);
+      if (!fieldMatch) continue;
+      const [, fieldName, rawTypeToken, remainder] = fieldMatch;
+      const list = rawTypeToken.endsWith("[]");
+      const optional = rawTypeToken.endsWith("?");
+      const baseType = rawTypeToken.replace(/\?|\[\]/g, "");
+      const referencesModel = modelNameSet.has(baseType) && !enumNames.has(baseType);
+      const hasRelationDirective = remainder.includes("@relation(");
+
+      if (referencesModel && hasRelationDirective) {
+        const relationMatch = remainder.match(/@relation\(([^)]*)\)/);
+        const relationArgs = relationMatch?.[1] || "";
+        const fieldsMatch = relationArgs.match(/fields:\s*\[([^\]]+)\]/);
+        const refsMatch = relationArgs.match(/references:\s*\[([^\]]+)\]/);
+        relations.push({
+          from_entity: `entity_${slugify(modelName)}`,
+          to_entity: `entity_${slugify(baseType)}`,
+          relation_field: fieldName,
+          fields: fieldsMatch ? fieldsMatch[1].split(",").map((field) => field.trim()) : [],
+          references: refsMatch ? refsMatch[1].split(",").map((field) => field.trim()) : []
+        });
+        continue;
+      }
+
+      if (referencesModel) continue;
+
+      const fieldType = enumNames.has(baseType) ? baseType : normalizePrismaType(baseType);
+      fields.push({
+        name: fieldName,
+        field_type: fieldType,
+        required: !optional && !list,
+        list,
+        unique: /@unique\b/.test(remainder),
+        primary_key: /@id\b/.test(remainder)
+      });
+
+      if (/@unique\b/.test(remainder)) {
+        localIndexes.push({
+          id_hint: `index_${slugify(`${modelName}_${fieldName}_unique`)}`,
+          fields: [fieldName],
+          unique: true
+        });
+      }
+    }
+
+    entities.push({ name: modelName, fields });
+    indexes.push(...localIndexes.map((index) => ({ ...index, entity: `entity_${slugify(modelName)}` })));
+  }
+
+  return { entities, enums, relations, indexes };
+}
+
+export const prismaExtractor = {
+  id: "db.prisma",
+  track: "db",
+  detect(context) {
+    const files = findImportFiles(context.paths, (filePath) => filePath.endsWith("/prisma/schema.prisma") || filePath.endsWith("prisma/schema.prisma"));
+    return {
+      score: files.length > 0 ? 100 : 0,
+      reasons: files.length > 0 ? ["Found Prisma schema"] : []
+    };
+  },
+  extract(context) {
+    const prismaFiles = selectPreferredImportFiles(
+      context.paths,
+      findImportFiles(context.paths, (filePath) => filePath.endsWith("/prisma/schema.prisma") || filePath.endsWith("prisma/schema.prisma")),
+      "prisma"
+    );
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    for (const filePath of prismaFiles) {
+      const parsed = parsePrismaSchema(context.helpers.readTextIfExists(filePath) || "");
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      findings.push({
+        kind: "prisma_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: "high",
+        sourceKind: "schema",
+        provenance,
+        table_name: slugify(entity.table_name || 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: "high",
+        sourceKind: "schema",
+        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: "high",
+        sourceKind: "schema",
+        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: "schema",
+        provenance,
+        entity: index.entity,
+        fields: index.fields,
+        unique: index.unique,
+        track: "db"
+      })));
+    }
+    return { findings, candidates };
+  }
+};
+