@topogram/cli 0.3.34

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

@@ -0,0 +1,242 @@
+import path from "node:path";
+
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  slugify,
+  titleCase
+} from "../../core/shared.js";
+
+function splitTopLevelEntries(block) {
+  const entries = [];
+  let current = "";
+  let depth = 0;
+  let inString = false;
+  let stringQuote = null;
+  for (let index = 0; index < block.length; index += 1) {
+    const char = block[index];
+    const prev = block[index - 1];
+    if (inString) {
+      current += char;
+      if (char === stringQuote && prev !== "\\") {
+        inString = false;
+        stringQuote = null;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      inString = true;
+      stringQuote = char;
+      current += char;
+      continue;
+    }
+    if (char === "{" || char === "[" || char === "(") {
+      depth += 1;
+      current += char;
+      continue;
+    }
+    if (char === "}" || char === "]" || char === ")") {
+      depth -= 1;
+      current += char;
+      continue;
+    }
+    if (char === "," && depth === 0) {
+      if (current.trim()) entries.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) entries.push(current.trim());
+  return entries;
+}
+
+function parseDrizzleFieldType(rawExpression) {
+  const expression = String(rawExpression || "");
+  const typeMatch = expression.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+  const fieldType = typeMatch ? typeMatch[1] : "unknown";
+  const enumMatch = expression.match(/\benum:\s*\[([^\]]+)\]/);
+  const enumValues = enumMatch
+    ? enumMatch[1]
+        .split(",")
+        .map((entry) => entry.trim().replace(/^["'`]|["'`]$/g, ""))
+        .filter(Boolean)
+    : [];
+  const referencesMatch = expression.match(/\.references\s*\(\s*\(\s*\)\s*=>\s*([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)/);
+  return {
+    field_type: fieldType,
+    enum_values: enumValues,
+    required: /\.notNull\s*\(/.test(expression),
+    unique: /\.unique\s*\(/.test(expression),
+    primary_key: /\.primaryKey\s*\(/.test(expression),
+    references: referencesMatch
+      ? {
+          target_table_symbol: referencesMatch[1],
+          target_field: referencesMatch[2]
+        }
+      : null
+  };
+}
+
+function parseDrizzleTables(schemaText) {
+  const entities = [];
+  const enums = [];
+  const relations = [];
+  const indexes = [];
+  const tableSymbolToEntity = new Map();
+  const enumRegistry = new Map();
+
+  for (const match of schemaText.matchAll(/export\s+const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*pgTable\s*\(\s*["'`]([^"'`]+)["'`]\s*,\s*\{([\s\S]*?)\}\s*(?:,\s*\(([^)]*?)\)\s*=>\s*\(\{([\s\S]*?)\}\))?\s*\)/g)) {
+    const [, tableSymbol, tableName, rawFieldsBlock, _tableArgs, rawIndexesBlock = ""] = match;
+    const entityStem = canonicalCandidateTerm(tableName);
+    const entityId = `entity_${entityStem}`;
+    const fields = [];
+    tableSymbolToEntity.set(tableSymbol, entityId);
+
+    for (const entry of splitTopLevelEntries(rawFieldsBlock)) {
+      const fieldMatch = entry.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([\s\S]+)$/);
+      if (!fieldMatch) continue;
+      const [, fieldName, rawExpression] = fieldMatch;
+      const parsedField = parseDrizzleFieldType(rawExpression);
+      fields.push({
+        name: fieldName,
+        field_type: parsedField.field_type,
+        required: parsedField.required || parsedField.primary_key,
+        list: false,
+        unique: parsedField.unique,
+        primary_key: parsedField.primary_key
+      });
+      if (parsedField.enum_values.length > 0) {
+        const enumId = `${entityStem}_${canonicalCandidateTerm(fieldName)}`;
+        if (!enumRegistry.has(enumId)) {
+          enumRegistry.set(enumId, {
+            id_hint: enumId,
+            label: titleCase(enumId),
+            values: parsedField.enum_values
+          });
+        }
+        fields[fields.length - 1].field_type = enumId;
+      }
+      if (parsedField.references) {
+        relations.push({
+          from_entity: entityId,
+          to_entity_symbol: parsedField.references.target_table_symbol,
+          relation_field: fieldName,
+          fields: [fieldName],
+          references: [parsedField.references.target_field]
+        });
+      }
+    }
+
+    for (const indexEntry of splitTopLevelEntries(rawIndexesBlock)) {
+      const indexMatch = indexEntry.match(/([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(unique|index)\s*\(\s*["'`]([^"'`]+)["'`]\s*\)\.on\(([\s\S]+)\)$/);
+      if (!indexMatch) continue;
+      const [, , indexType, indexName, rawColumns] = indexMatch;
+      const fieldsForIndex = [...rawColumns.matchAll(/table\.([A-Za-z_][A-Za-z0-9_]*)/g)].map((entry) => entry[1]);
+      indexes.push({
+        id_hint: idHintify(indexName),
+        entity: entityId,
+        fields: fieldsForIndex,
+        unique: indexType === "unique"
+      });
+    }
+
+    entities.push({
+      name: entityStem,
+      table_name: tableName,
+      fields
+    });
+  }
+
+  for (const relation of relations) {
+    relation.to_entity = tableSymbolToEntity.get(relation.to_entity_symbol) || `entity_${canonicalCandidateTerm(relation.to_entity_symbol)}`;
+    delete relation.to_entity_symbol;
+  }
+
+  return {
+    entities,
+    enums: [...enumRegistry.values()],
+    relations,
+    indexes
+  };
+}
+
+export const drizzleExtractor = {
+  id: "db.drizzle",
+  track: "db",
+  detect(context) {
+    const hasConfig = findImportFiles(context.paths, (filePath) => /drizzle\.config\.(ts|js|mjs|cjs)$/i.test(path.basename(filePath))).length > 0;
+    const hasSchema = findImportFiles(context.paths, (filePath) => /src\/schema\.(ts|js|mjs|cjs)$/i.test(filePath)).length > 0;
+    return {
+      score: hasConfig || hasSchema ? 95 : 0,
+      reasons: hasConfig || hasSchema ? ["Found Drizzle config/schema source"] : []
+    };
+  },
+  extract(context) {
+    const schemaFiles = findImportFiles(context.paths, (filePath) => /src\/schema\.(ts|js|mjs|cjs)$/i.test(filePath));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    for (const filePath of schemaFiles) {
+      const parsed = parseDrizzleTables(context.helpers.readTextIfExists(filePath) || "");
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      findings.push({
+        kind: "drizzle_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: entity.table_name,
+        fields: entity.fields,
+        track: "db"
+      })));
+      candidates.enums.push(...parsed.enums.map((entry) => makeCandidateRecord({
+        kind: "enum",
+        idHint: entry.id_hint,
+        label: entry.label,
+        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"
+      })));
+    }
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    candidates.enums = dedupeCandidateRecords(candidates.enums, (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/ef-core.js

@@ -0,0 +1,221 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  makeCandidateRecord,
+  readTextIfExists,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function splitClassBlocks(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  const blocks = [];
+  let current = null;
+
+  for (const line of lines) {
+    const match = line.match(/^public\s+class\s+([A-Za-z_][A-Za-z0-9_]*)\b/);
+    if (match) {
+      if (current) blocks.push(current);
+      current = { name: match[1], lines: [line] };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+
+  if (current) blocks.push(current);
+  return blocks;
+}
+
+function parseProperties(block) {
+  const properties = [];
+  const notMapped = new Set();
+  let pendingNotMapped = false;
+
+  for (const rawLine of block.lines.slice(1)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (/^\[NotMapped\]/.test(line)) {
+      pendingNotMapped = true;
+      continue;
+    }
+    const match = line.match(/^public\s+([A-Za-z0-9_<>\[\]\?., ]+)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{/);
+    if (!match) continue;
+    const [, typeName, name] = match;
+    properties.push({ name, typeName: typeName.trim(), notMapped: pendingNotMapped });
+    if (pendingNotMapped) {
+      notMapped.add(name);
+      pendingNotMapped = false;
+    }
+  }
+
+  return properties;
+}
+
+function normalizeScalarType(typeName) {
+  const normalized = String(typeName || "").replace(/\?$/, "").trim();
+  if (["string", "byte[]"].includes(normalized)) return "string";
+  if (["int", "long", "short"].includes(normalized)) return "int";
+  if (["bool", "boolean"].includes(normalized.toLowerCase())) return "boolean";
+  if (["DateTime", "DateTimeOffset"].includes(normalized)) return "datetime";
+  return normalized;
+}
+
+function unwrapListType(typeName) {
+  const listMatch = String(typeName || "").match(/List<([^>]+)>/);
+  return listMatch ? listMatch[1].trim() : null;
+}
+
+function domainEntityInfo(name, properties, trackedNames) {
+  const scalarFields = [];
+  const relations = [];
+
+  const entityStem =
+    name === "Person" ? "user" :
+    canonicalCandidateTerm(name);
+
+  const entityId = `entity_${entityStem}`;
+
+  const scalarLike = (typeName) => {
+    const base = String(typeName || "").replace(/\?$/, "").trim();
+    return ["string", "int", "long", "short", "bool", "byte[]", "DateTime", "DateTimeOffset"].includes(base);
+  };
+
+  const scalarIdOnlyCount = properties.filter((property) => /Id$/.test(property.name)).length;
+  const relationReferenceCount = properties.filter((property) => {
+    const base = property.typeName.replace(/\?$/, "").trim();
+    return trackedNames.has(base) || trackedNames.has((unwrapListType(base) || "").trim());
+  }).length;
+  const relationOnlyEntity =
+    properties.length > 0 &&
+    scalarIdOnlyCount >= 2 &&
+    relationReferenceCount >= 2 &&
+    properties.every((property) => {
+      const base = property.typeName.replace(/\?$/, "").trim();
+      return /Id$/.test(property.name) || trackedNames.has(base) || trackedNames.has((unwrapListType(base) || "").trim());
+    });
+
+  for (const property of properties) {
+    if (property.notMapped) continue;
+    const baseType = property.typeName.replace(/\?$/, "").trim();
+    const listType = unwrapListType(baseType);
+    const required = !property.typeName.includes("?") && baseType !== "string" && baseType !== "byte[]";
+
+    if (scalarLike(baseType)) {
+      if (["Hash", "Salt"].includes(property.name)) continue;
+      scalarFields.push({
+        name: property.name.charAt(0).toLowerCase() + property.name.slice(1),
+        field_type: normalizeScalarType(baseType),
+        required: baseType !== "string" ? required : false,
+        list: false,
+        unique: ["Email", "Username", "Slug", "TagId"].includes(property.name),
+        primary_key: /Id$/.test(property.name) && [name, "Tag"].some((part) => property.name === `${part}Id`)
+      });
+      continue;
+    }
+
+    if (trackedNames.has(baseType)) {
+      relations.push({
+        from_entity: entityId,
+        to_entity: `entity_${baseType === "Person" ? "user" : canonicalCandidateTerm(baseType)}`,
+        relation_field: property.name.charAt(0).toLowerCase() + property.name.slice(1),
+        fields: [property.name.charAt(0).toLowerCase() + property.name.slice(1)],
+        references: ["id"],
+        relation_type: "reference"
+      });
+      continue;
+    }
+
+    if (listType && trackedNames.has(listType)) {
+      relations.push({
+        from_entity: entityId,
+        to_entity: `entity_${listType === "Person" ? "user" : canonicalCandidateTerm(listType)}`,
+        relation_field: property.name.charAt(0).toLowerCase() + property.name.slice(1),
+        fields: [property.name.charAt(0).toLowerCase() + property.name.slice(1)],
+        references: ["id"],
+        relation_type: "collection"
+      });
+    }
+  }
+
+  return {
+    entity: {
+      id_hint: entityId,
+      label: titleCase(entityStem),
+      model_name: name,
+      fields: scalarFields,
+      noise_candidate: relationOnlyEntity,
+      noise_reason: relationOnlyEntity ? "EF Core relationship-link entity inferred as implementation noise." : null
+    },
+    relations
+  };
+}
+
+export const efCoreExtractor = {
+  id: "db.ef-core",
+  track: "db",
+  detect(context) {
+    const csprojFiles = findImportFiles(context.paths, (filePath) => /\.csproj$/i.test(filePath));
+    const dbContextFiles = findImportFiles(context.paths, (filePath) => /DbContext|Context\.cs$/i.test(filePath));
+    const score = csprojFiles.length > 0 && dbContextFiles.some((filePath) => /DbContext/.test(readTextIfExists(filePath) || "")) ? 89 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found .NET project with EF Core DbContext"] : []
+    };
+  },
+  extract(context) {
+    const dbContextFiles = findImportFiles(context.paths, (filePath) => /DbContext|Context\.cs$/i.test(filePath));
+    const domainFiles = findImportFiles(context.paths, (filePath) => /\/Domain\/.+\.cs$/i.test(filePath));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+
+    const trackedNames = new Set();
+    for (const filePath of dbContextFiles) {
+      const text = readTextIfExists(filePath) || "";
+      for (const match of text.matchAll(/DbSet<([A-Za-z_][A-Za-z0-9_]*)>/g)) {
+        trackedNames.add(match[1]);
+      }
+    }
+
+    for (const filePath of domainFiles) {
+      const text = readTextIfExists(filePath) || "";
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      for (const block of splitClassBlocks(text)) {
+        if (!trackedNames.has(block.name)) continue;
+        const parsed = domainEntityInfo(block.name, parseProperties(block), trackedNames);
+        findings.push({
+          kind: "ef_core_entity",
+          file: provenance,
+          entity: parsed.entity.id_hint
+        });
+        candidates.entities.push(makeCandidateRecord({
+          kind: "entity",
+          idHint: parsed.entity.id_hint,
+          label: parsed.entity.label,
+          confidence: "high",
+          sourceKind: "schema",
+          provenance,
+          model_name: parsed.entity.model_name,
+          fields: parsed.entity.fields,
+          noise_candidate: parsed.entity.noise_candidate,
+          noise_reason: parsed.entity.noise_reason,
+          track: "db"
+        }));
+        candidates.relations.push(...parsed.relations.map((relation) => makeCandidateRecord({
+          kind: "relation",
+          idHint: `${relation.from_entity}_${relation.relation_field}_${relation.to_entity}`.replace(/[^a-zA-Z0-9_]+/g, "_").toLowerCase(),
+          label: `${relation.from_entity} -> ${relation.to_entity}`,
+          confidence: "medium",
+          sourceKind: "schema",
+          provenance,
+          ...relation,
+          track: "db"
+        })));
+      }
+    }
+
+    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/db/flutter-entities.js

@@ -0,0 +1,120 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function normalizeDartFieldType(typeName) {
+  const normalized = String(typeName || "").replace(/\?$/, "").trim();
+  switch (normalized) {
+    case "String": return "string";
+    case "int": return "int";
+    case "double": return "double";
+    case "bool": return "boolean";
+    case "DateTime": return "datetime";
+    default: return idHintify(normalized) || "string";
+  }
+}
+
+function featureStemFromPath(filePath) {
+  return canonicalCandidateTerm(filePath.match(/\/features\/([^/]+)\//)?.[1] || "item");
+}
+
+function parseEntityFile(text, provenance, filePath) {
+  const classMatch = String(text || "").match(/class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{/m);
+  if (!classMatch) return null;
+  const className = classMatch[1];
+  const fields = [...String(text || "").matchAll(/final\s+([A-Za-z0-9_<>\?]+)\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/g)]
+    .map((match) => ({
+      name: match[2],
+      field_type: normalizeDartFieldType(match[1]),
+      required: !String(match[1]).includes("?"),
+      list: /^List</.test(match[1]),
+      unique: false,
+      primary_key: /^id$/i.test(match[2])
+    }));
+  if (fields.length === 0) return null;
+  const stem = featureStemFromPath(filePath);
+  return makeCandidateRecord({
+    kind: "entity",
+    idHint: `entity_${stem}`,
+    label: titleCase(stem),
+    confidence: "high",
+    sourceKind: "schema",
+    provenance,
+    model_name: className,
+    fields,
+    track: "db"
+  });
+}
+
+function parseEnums(text, provenance, filePath) {
+  const stem = featureStemFromPath(filePath);
+  const enums = [];
+  for (const match of String(text || "").matchAll(/enum\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{([\s\S]*?)\}/g)) {
+    const enumName = canonicalCandidateTerm(idHintify(match[1].replace(/([a-z0-9])([A-Z])/g, "$1_$2")));
+    const values = match[2]
+      .split(",")
+      .map((value) => value.trim())
+      .filter(Boolean)
+      .map((value) => value.replace(/\(.*$/, "").trim())
+      .filter(Boolean);
+    if (values.length === 0) continue;
+    enums.push(makeCandidateRecord({
+      kind: "enum",
+      idHint: `enum_${stem}_${enumName}`,
+      label: titleCase(enumName),
+      confidence: "medium",
+      sourceKind: "schema",
+      provenance,
+      values,
+      track: "db"
+    }));
+  }
+  return enums;
+}
+
+export const flutterEntitiesExtractor = {
+  id: "db.flutter-entities",
+  track: "db",
+  detect(context) {
+    const entityFiles = findImportFiles(
+      context.paths,
+      (filePath) => /\/lib\/features\/.+\/domain\/entities\/.+_entity\.dart$/i.test(filePath)
+    );
+    const score = entityFiles.length > 0 ? 83 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found Flutter feature domain entities"] : []
+    };
+  },
+  extract(context) {
+    const entityFiles = findImportFiles(
+      context.paths,
+      (filePath) => /\/lib\/features\/.+\/domain\/entities\/.+_entity\.dart$/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) {
+        candidates.entities.push(entity);
+      }
+      candidates.enums.push(...parseEnums(text, provenance, filePath));
+      findings.push({
+        kind: "flutter_domain_entity",
+        file: provenance,
+        entity_id: entity?.id_hint || null
+      });
+    }
+    candidates.entities = dedupeCandidateRecords(candidates.entities, (record) => record.id_hint);
+    candidates.enums = dedupeCandidateRecords(candidates.enums, (record) => record.id_hint);
+    return { findings, candidates };
+  }
+};