@topogram/cli 0.3.34

package/src/import/extractors/db/rails-schema.js

@@ -0,0 +1,175 @@
+import path from "node:path";
+
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  slugify,
+  titleCase
+} from "../../core/shared.js";
+
+function parseRailsArray(rawValue) {
+  return [...String(rawValue || "").matchAll(/["']([^"']+)["']/g)].map((entry) => entry[1]);
+}
+
+function parseRailsColumns(block) {
+  const fields = [];
+  const indexes = [];
+  const lines = String(block || "").split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    const columnMatch = trimmed.match(/^t\.([a-z_]+)\s+"([^"]+)"(.*)$/i);
+    if (columnMatch) {
+      const [, rawType, fieldName, options = ""] = columnMatch;
+      if (rawType !== "index") {
+        fields.push({
+          name: fieldName,
+          field_type: rawType.toLowerCase(),
+          required: /null:\s*false/.test(options),
+          list: false,
+          unique: false,
+          primary_key: false
+        });
+      }
+      continue;
+    }
+
+    const indexMatch = trimmed.match(/^t\.index\s+(\[[^\]]+\]|"[^"]+")\s*,\s*name:\s*"([^"]+)"(.*)$/i);
+    if (indexMatch) {
+      const [, rawFields, indexName, options = ""] = indexMatch;
+      const fieldsForIndex = rawFields.startsWith("[")
+        ? parseRailsArray(rawFields)
+        : [rawFields.replace(/^"|"$/g, "")];
+      indexes.push({
+        id_hint: idHintify(indexName),
+        fields: fieldsForIndex,
+        unique: /unique:\s*true/.test(options)
+      });
+    }
+  }
+  return { fields, indexes };
+}
+
+function parseRailsSchema(schemaText) {
+  const entities = [];
+  const indexes = [];
+  const relations = [];
+  const entityFieldMap = new Map();
+
+  for (const match of schemaText.matchAll(/create_table\s+"([^"]+)"[\s\S]*?do\s+\|t\|\n([\s\S]*?)^\s*end$/gm)) {
+    const [, tableName, block] = match;
+    const entityStem = canonicalCandidateTerm(tableName);
+    const entityId = `entity_${entityStem}`;
+    const parsed = parseRailsColumns(block);
+    entities.push({
+      id_hint: entityId,
+      label: titleCase(entityStem),
+      table_name: tableName,
+      fields: parsed.fields
+    });
+    entityFieldMap.set(tableName, parsed.fields);
+    indexes.push(...parsed.indexes.map((index) => ({
+      ...index,
+      entity: entityId
+    })));
+  }
+
+  for (const match of schemaText.matchAll(/add_foreign_key\s+"([^"]+)"\s*,\s*"([^"]+)"/g)) {
+    const [, fromTable, toTable] = match;
+    const fromEntity = `entity_${canonicalCandidateTerm(fromTable)}`;
+    const toEntity = `entity_${canonicalCandidateTerm(toTable)}`;
+    const candidateFieldNames = [
+      `${canonicalCandidateTerm(toTable).replace(/-/g, "_")}_id`,
+      `${canonicalCandidateTerm(toTable).replace(/-/g, "_")}Id`
+    ];
+    const knownFields = entityFieldMap.get(fromTable) || [];
+    const relationField = candidateFieldNames.find((fieldName) => knownFields.some((field) => field.name === fieldName))
+      || knownFields.find((field) => field.name.endsWith("_id"))?.name
+      || `${canonicalCandidateTerm(toTable).replace(/-/g, "_")}_id`;
+    relations.push({
+      from_entity: fromEntity,
+      to_entity: toEntity,
+      relation_field: relationField,
+      fields: [relationField],
+      references: ["id"]
+    });
+  }
+
+  return { entities, indexes, relations };
+}
+
+export const railsSchemaExtractor = {
+  id: "db.rails-schema",
+  track: "db",
+  detect(context) {
+    const schemaFiles = findImportFiles(context.paths, (filePath) => /db\/schema\.rb$/i.test(filePath));
+    return {
+      score: schemaFiles.length > 0 ? 92 : 0,
+      reasons: schemaFiles.length > 0 ? ["Found Rails schema.rb"] : []
+    };
+  },
+  extract(context) {
+    const schemaFiles = findImportFiles(context.paths, (filePath) => /db\/schema\.rb$/i.test(filePath));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+
+    for (const filePath of schemaFiles) {
+      const schemaText = context.helpers.readTextIfExists(filePath) || "";
+      const parsed = parseRailsSchema(schemaText);
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+
+      findings.push({
+        kind: "rails_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,
+        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"
+      })));
+    }
+
+    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/react-native-entities.js

@@ -0,0 +1,95 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function normalizeTsFieldType(typeName) {
+  const normalized = String(typeName || "").trim().replace(/\[\]$/, "");
+  switch (normalized) {
+    case "string": return "string";
+    case "number": return "int";
+    case "boolean": return "boolean";
+    default: return idHintify(normalized) || "string";
+  }
+}
+
+function contextStemFromPath(filePath) {
+  const contextMatch = String(filePath || "").match(/\/src\/([^/]+)\//);
+  const entityMatch = String(filePath || "").match(/\/([^/]+)Entity\.ts$/);
+  return canonicalCandidateTerm(
+    entityMatch?.[1] ||
+    contextMatch?.[1] ||
+    "item"
+  );
+}
+
+function parseEntityFile(text, provenance, filePath) {
+  const interfaceMatch = String(text || "").match(/interface\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([\s\S]*?)\}/m);
+  if (!interfaceMatch) return null;
+  const [, interfaceName, body] = interfaceMatch;
+  const fields = [...String(body || "").matchAll(/([A-Za-z_][A-Za-z0-9_]*)\??:\s*([^;\n]+)/g)]
+    .map((match) => ({
+      name: match[1],
+      field_type: normalizeTsFieldType(match[2]),
+      required: !match[0].includes("?:"),
+      list: /\[\]\s*$/.test(match[2]),
+      unique: false,
+      primary_key: /^id$/i.test(match[1])
+    }));
+  if (fields.length === 0) return null;
+  const stem = contextStemFromPath(filePath);
+  return makeCandidateRecord({
+    kind: "entity",
+    idHint: `entity_${stem}`,
+    label: titleCase(stem),
+    confidence: "high",
+    sourceKind: "schema",
+    provenance,
+    model_name: interfaceName,
+    fields,
+    track: "db"
+  });
+}
+
+export const reactNativeEntitiesExtractor = {
+  id: "db.react-native-entities",
+  track: "db",
+  detect(context) {
+    const entityFiles = findImportFiles(
+      context.paths,
+      (filePath) => /\/src\/.+\/domain\/entities\/.+Entity\.ts$/i.test(filePath)
+    );
+    const score = entityFiles.length > 0 ? 82 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found React Native domain entity interfaces"] : []
+    };
+  },
+  extract(context) {
+    const entityFiles = findImportFiles(
+      context.paths,
+      (filePath) => /\/src\/.+\/domain\/entities\/.+Entity\.ts$/i.test(filePath)
+    );
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    for (const filePath of entityFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const entity = parseEntityFile(text, provenance, filePath);
+      if (!entity) continue;
+      findings.push({
+        kind: "react_native_domain_entity",
+        file: provenance,
+        entity_id: entity.id_hint
+      });
+      candidates.entities.push(entity);
+    }
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    return { findings, candidates };
+  }
+};

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

@@ -0,0 +1,193 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function kotlinTypeToFieldType(typeName) {
+  const normalized = String(typeName || "").replace(/\?$/, "");
+  switch (normalized) {
+    case "String": return "string";
+    case "Int": return "int";
+    case "Long": return "bigint";
+    case "Float": return "float";
+    case "Double": return "double";
+    case "Boolean": return "boolean";
+    default:
+      if (/^List<.+>$/.test(normalized)) return "json";
+      return normalized || "string";
+  }
+}
+
+function roomEntityStem(name) {
+  return idHintify(
+    canonicalCandidateTerm(
+      String(name || "").replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    )
+  );
+}
+
+function parseEntityFile(text, provenance) {
+  const classMatch = String(text || "").match(/@Entity(?:\([^)]*\))?[\s\S]*?data\s+class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*?)\)\s*$/m);
+  if (!classMatch) return null;
+  const className = classMatch[1];
+  const fieldsBlock = classMatch[2];
+  const fields = [];
+  let currentPrimaryKey = false;
+
+  for (const rawLine of fieldsBlock.split(/\r?\n/)) {
+    const line = rawLine.trim().replace(/,$/, "");
+    if (!line) continue;
+    if (line.startsWith("@PrimaryKey")) {
+      currentPrimaryKey = true;
+      continue;
+    }
+    const match = line.match(/^(?:var|val)\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([^=,]+)/);
+    if (!match) continue;
+    const [, name, typeName] = match;
+    const required = !String(typeName).includes("?");
+    fields.push({
+      name,
+      field_type: kotlinTypeToFieldType(typeName.trim()),
+      required,
+      list: /^List</.test(String(typeName).trim()),
+      unique: false,
+      primary_key: currentPrimaryKey
+    });
+    currentPrimaryKey = false;
+  }
+
+  const entityStem = roomEntityStem(className.replace(/Entity$/, ""));
+  return makeCandidateRecord({
+    kind: "entity",
+    idHint: `entity_${entityStem}`,
+    label: titleCase(entityStem),
+    confidence: "high",
+    sourceKind: "schema",
+    provenance,
+    model_name: className,
+    fields,
+    track: "db"
+  });
+}
+
+function inferDaoCapability(daoName, methodName, queryText) {
+    const entityStem = roomEntityStem(daoName.replace(/Dao$/, "").replace(/Info$/, "_info"));
+  const normalizedMethod = methodName.toLowerCase();
+  if (/insert|upsert|save|create/.test(normalizedMethod)) return `cap_create_${entityStem}`;
+  if (/getall|list|fetchall/.test(normalizedMethod)) return `cap_list_${entityStem}s`;
+  if (/get|fetch|load/.test(normalizedMethod)) return `cap_get_${entityStem}`;
+  if (/delete|remove/.test(normalizedMethod)) return `cap_delete_${entityStem}`;
+  if (/update|edit/.test(normalizedMethod)) return `cap_update_${entityStem}`;
+  if (/select \*/i.test(queryText || "") && /where/i.test(queryText || "")) return `cap_get_${entityStem}`;
+  if (/select \*/i.test(queryText || "")) return `cap_list_${entityStem}s`;
+  return null;
+}
+
+function parseDaoFile(text, provenance) {
+  const daoMatch = String(text || "").match(/@Dao[\s\S]*?interface\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{/m);
+  if (!daoMatch) return [];
+  const daoName = daoMatch[1];
+  const capabilities = [];
+  let pendingQuery = null;
+  let pendingInsert = false;
+
+  for (const rawLine of String(text || "").split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const queryMatch = line.match(/^@Query\("(.+)"\)$/);
+    if (queryMatch) {
+      pendingQuery = queryMatch[1];
+      pendingInsert = false;
+      continue;
+    }
+    if (/^@Insert\b/.test(line)) {
+      pendingInsert = true;
+      pendingQuery = null;
+      continue;
+    }
+    const methodMatch = line.match(/fun\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([\s\S]*?)\)\s*:\s*([A-Za-z0-9_<>,?. ]+)/);
+    if (!methodMatch) continue;
+    const methodName = methodMatch[1];
+    const params = methodMatch[2];
+    const returnType = methodMatch[3].trim();
+    const entityStem = canonicalCandidateTerm(daoName.replace(/Dao$/, "").replace(/Info$/, "_info"));
+    const capabilityId = pendingInsert
+      ? `cap_create_${entityStem}`
+      : inferDaoCapability(daoName, methodName, pendingQuery);
+    if (!capabilityId) {
+      pendingInsert = false;
+      pendingQuery = null;
+      continue;
+    }
+    const queryParams = [...String(params || "").matchAll(/([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z0-9_<>,?.]+)/g)]
+      .map((entry) => ({ name: entry[1], required: !entry[2].includes("?"), type: entry[2] }));
+    capabilities.push(makeCandidateRecord({
+      kind: "capability",
+      idHint: capabilityId,
+      label: titleCase(capabilityId.replace(/^cap_/, "")),
+      confidence: "medium",
+      sourceKind: "schema",
+      provenance,
+      entity_id: `entity_${entityStem}`,
+      dao_name: daoName,
+      dao_method: methodName,
+      query: pendingQuery,
+      input_fields: queryParams.map((entry) => entry.name),
+      output_fields: /^List</.test(returnType) ? [canonicalCandidateTerm(entityStem), `${canonicalCandidateTerm(entityStem)}s`] : [canonicalCandidateTerm(entityStem)],
+      track: "db"
+    }));
+    pendingInsert = false;
+    pendingQuery = null;
+  }
+
+  return capabilities;
+}
+
+export const roomExtractor = {
+  id: "db.room",
+  track: "db",
+  detect(context) {
+    const entityFiles = findImportFiles(context.paths, (filePath) => /Entity\.kt$/i.test(filePath) || /\/entitiy\/.+\.kt$/i.test(filePath) || /\/entity\/.+\.kt$/i.test(filePath));
+    const daoFiles = findImportFiles(context.paths, (filePath) => /Dao\.kt$/i.test(filePath));
+    const score = entityFiles.length > 0 && daoFiles.length > 0 ? 89 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found Android Room entities and DAO interfaces"] : []
+    };
+  },
+  extract(context) {
+    const entityFiles = findImportFiles(context.paths, (filePath) => /Entity\.kt$/i.test(filePath) || /\/entitiy\/.+\.kt$/i.test(filePath) || /\/entity\/.+\.kt$/i.test(filePath));
+    const daoFiles = findImportFiles(context.paths, (filePath) => /Dao\.kt$/i.test(filePath));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+
+    for (const filePath of entityFiles) {
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const parsed = parseEntityFile(context.helpers.readTextIfExists(filePath) || "", provenance);
+      if (!parsed) continue;
+      candidates.entities.push(parsed);
+    }
+
+    const daoCapabilities = [];
+    for (const filePath of daoFiles) {
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      daoCapabilities.push(...parseDaoFile(context.helpers.readTextIfExists(filePath) || "", provenance));
+    }
+
+    if (candidates.entities.length > 0 || daoCapabilities.length > 0) {
+      findings.push({
+        kind: "android_room",
+        entities: candidates.entities.length,
+        dao_capabilities: daoCapabilities.length
+      });
+    }
+
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    candidates.indexes = dedupeCandidateRecords(daoCapabilities, (record) => record.id_hint);
+    return { findings, candidates };
+  }
+};

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

@@ -0,0 +1,112 @@
+import { findImportFiles, makeCandidateRecord, relativeTo, slugify, titleCase, idHintify } from "../../core/shared.js";
+
+function parseDbSchemaSnapshot(snapshot) {
+  return {
+    entities: (snapshot.tables || []).map((table) => ({
+      name: table.table,
+      table_name: table.table,
+      fields: (table.columns || []).map((column) => ({
+        name: column.name,
+        field_type: column.type,
+        required: !column.nullable,
+        list: false,
+        unique: false,
+        primary_key: Boolean(column.primaryKey)
+      }))
+    })),
+    enums: (snapshot.enums || []).map((entry) => ({
+      name: entry.id,
+      values: entry.values || []
+    })),
+    relations: (snapshot.tables || []).flatMap((table) =>
+      (table.foreignKeys || []).map((foreignKey) => ({
+        from_entity: `entity_${slugify(table.table)}`,
+        to_entity: `entity_${slugify(foreignKey.referencesTable)}`,
+        relation_field: foreignKey.columns?.[0] || "relation",
+        fields: foreignKey.columns || [],
+        references: foreignKey.referencesColumns || []
+      }))
+    ),
+    indexes: (snapshot.tables || []).flatMap((table) =>
+      (table.indexes || []).map((index) => ({
+        id_hint: idHintify(index.name || `${table.table}_${(index.columns || []).join("_")}`),
+        entity: `entity_${slugify(table.table)}`,
+        fields: index.columns || [],
+        unique: Boolean(index.unique)
+      }))
+    )
+  };
+}
+
+export const snapshotExtractor = {
+  id: "db.snapshot",
+  track: "db",
+  detect(context) {
+    const files = findImportFiles(context.paths, (filePath) => filePath.endsWith(".db-schema-snapshot.json"));
+    return {
+      score: files.length > 0 ? 40 : 0,
+      reasons: files.length > 0 ? ["Found DB schema snapshot artifacts"] : []
+    };
+  },
+  extract(context) {
+    const snapshotFiles = findImportFiles(context.paths, (filePath) => filePath.endsWith(".db-schema-snapshot.json"));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    for (const filePath of snapshotFiles) {
+      const snapshot = context.helpers.readJsonIfExists(filePath);
+      if (!snapshot) continue;
+      const parsed = parseDbSchemaSnapshot(snapshot);
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      findings.push({
+        kind: "db_schema_snapshot",
+        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: "medium",
+        sourceKind: "generated_artifact",
+        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: "medium",
+        sourceKind: "generated_artifact",
+        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: "generated_artifact",
+        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: "generated_artifact",
+        provenance,
+        entity: index.entity,
+        fields: index.fields,
+        unique: index.unique,
+        track: "db"
+      })));
+    }
+    return { findings, candidates };
+  }
+};