@topogram/cli 0.3.34

package/src/import/extractors/api/trpc.js

@@ -0,0 +1,212 @@
+import {
+  dedupeCandidateRecords,
+  findImportFiles,
+  inferApiEntityIdFromPath,
+  makeCandidateRecord,
+  pluralizeCandidateTerm,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function splitTopLevelProperties(block) {
+  const props = [];
+  let current = "";
+  let depth = 0;
+  let inString = false;
+  let quote = null;
+  for (let i = 0; i < block.length; i += 1) {
+    const ch = block[i];
+    const prev = block[i - 1];
+    if (inString) {
+      current += ch;
+      if (ch === quote && prev !== "\\") {
+        inString = false;
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      inString = true;
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[" || ch === "(") {
+      depth += 1;
+      current += ch;
+      continue;
+    }
+    if (ch === "}" || ch === "]" || ch === ")") {
+      depth -= 1;
+      current += ch;
+      continue;
+    }
+    if (ch === "," && depth === 0) {
+      if (current.trim()) props.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) props.push(current.trim());
+  return props;
+}
+
+function parseInputFields(entryBody) {
+  const objectMatch = entryBody.match(/\.input\s*\(\s*z\.object\s*\(\s*\{([\s\S]*?)\}\s*\)\s*(?:,|\))/m);
+  if (!objectMatch) return [];
+  const fields = [];
+  for (const prop of splitTopLevelProperties(objectMatch[1])) {
+    const propMatch = prop.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:/);
+    if (propMatch) fields.push(propMatch[1]);
+  }
+  return [...new Set(fields)].sort();
+}
+
+function parseNamedSelects(text) {
+  const namedSelects = new Map();
+  for (const match of text.matchAll(/const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\{([\s\S]*?)\}\s*satisfies\s+Prisma\.[A-Za-z_][A-Za-z0-9_]*Select/g)) {
+    const fields = [];
+    for (const prop of splitTopLevelProperties(match[2])) {
+      const propMatch = prop.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:/);
+      if (propMatch) fields.push(propMatch[1]);
+    }
+    namedSelects.set(match[1], [...new Set(fields)].sort());
+  }
+  return namedSelects;
+}
+
+function inferOutputFields(entryBody, procedureType, resource, namedSelects) {
+  const returnObjectMatch = entryBody.match(/return\s*\{([\s\S]*?)\}\s*;?\s*$/m);
+  if (returnObjectMatch) {
+    const fields = [];
+    for (const prop of splitTopLevelProperties(returnObjectMatch[1])) {
+      const propMatch = prop.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*[:(]/);
+      if (propMatch) fields.push(propMatch[1]);
+    }
+    return [...new Set(fields)].sort();
+  }
+  const selectRefMatch = entryBody.match(/select\s*:\s*([A-Za-z_][A-Za-z0-9_]*)/);
+  if (selectRefMatch && namedSelects.has(selectRefMatch[1])) {
+    return namedSelects.get(selectRefMatch[1]) || [];
+  }
+  if (procedureType === "query" && /\bfindUnique\b|\bbyId\b/.test(entryBody)) {
+    return [resource];
+  }
+  if (procedureType === "mutation" && /\bcreate\b/.test(entryBody)) {
+    return [resource];
+  }
+  return [];
+}
+
+function inferCapabilityId(routerResource, procedureName, procedureType) {
+  const resource = routerResource.replace(/-/g, "_");
+  if (/^list$/i.test(procedureName)) return `cap_list_${pluralizeCandidateTerm(resource)}`;
+  if (/^(byid|get|detail)$/i.test(procedureName)) return `cap_get_${resource}`;
+  if (/^(add|create|new)$/i.test(procedureName)) return `cap_create_${resource}`;
+  if (/^(update|edit|patch)$/i.test(procedureName)) return `cap_update_${resource}`;
+  if (/^(delete|remove)$/i.test(procedureName)) return `cap_delete_${resource}`;
+  const verb = procedureType === "mutation" ? "mutate" : "get";
+  return `cap_${verb}_${resource}_${procedureName.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase()}`;
+}
+
+function inferEndpointPath(routerResource, procedureName, procedureType) {
+  const resourcePath = `/${pluralizeCandidateTerm(routerResource).replace(/_/g, "-")}`;
+  if (/^list$/i.test(procedureName)) return { method: "GET", path: resourcePath };
+  if (/^(byid|get|detail)$/i.test(procedureName)) return { method: "GET", path: `${resourcePath}/{id}` };
+  if (/^(add|create|new)$/i.test(procedureName)) return { method: "POST", path: resourcePath };
+  if (/^(update|edit|patch)$/i.test(procedureName)) return { method: "PATCH", path: `${resourcePath}/{id}` };
+  if (/^(delete|remove)$/i.test(procedureName)) return { method: "DELETE", path: `${resourcePath}/{id}` };
+  return { method: procedureType === "mutation" ? "POST" : "GET", path: `${resourcePath}/${procedureName}` };
+}
+
+function parseRouterProcedures(filePath, text) {
+  const routerDecl = text.match(/export\s+const\s+([A-Za-z_][A-Za-z0-9_]*)Router\s*=\s*router\s*\(\s*\{/m);
+  if (!routerDecl) return [];
+  const routerName = routerDecl[1];
+  const routerResource = routerName.replace(/Router$/, "").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+  const routerText = text.slice(routerDecl.index);
+  const namedSelects = parseNamedSelects(text);
+  const procedures = [];
+  for (const entryMatch of routerText.matchAll(/(^|\n)\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*publicProcedure([\s\S]*?)\.(query|mutation)\s*\(\s*async\s*\([^)]*\)\s*=>\s*\{([\s\S]*?)\}\s*\)\s*,?/g)) {
+    const procedureName = entryMatch[2];
+    const entryBody = entryMatch[3];
+    const procedureType = entryMatch[4];
+    const resolverBody = entryMatch[5];
+    const endpoint = inferEndpointPath(routerResource, procedureName, procedureType);
+    const capabilityId = inferCapabilityId(routerResource, procedureName, procedureType);
+    procedures.push({
+      file: filePath,
+      routerName,
+      routerResource,
+      procedureName,
+      procedureType,
+      id_hint: capabilityId,
+      endpoint,
+      input_fields: parseInputFields(entryBody),
+      output_fields: inferOutputFields(resolverBody, procedureType, routerResource, namedSelects),
+      entity_id: inferApiEntityIdFromPath(endpoint.path),
+      auth_hint: /protectedProcedure/.test(entryBody) ? "secured" : "public"
+    });
+  }
+  return procedures;
+}
+
+export const trpcExtractor = {
+  id: "api.trpc",
+  track: "api",
+  detect(context) {
+    const routerFiles = findImportFiles(context.paths, (filePath) => /src\/server\/routers\/.+\.(ts|tsx|js|jsx)$/i.test(filePath));
+    const trpcHandler = findImportFiles(context.paths, (filePath) => /src\/pages\/api\/trpc\/\[trpc\]\.(ts|tsx|js|jsx)$/i.test(filePath));
+    return {
+      score: routerFiles.length > 0 && trpcHandler.length > 0 ? 88 : 0,
+      reasons: routerFiles.length > 0 && trpcHandler.length > 0 ? ["Found tRPC router modules and Next.js tRPC handler"] : []
+    };
+  },
+  extract(context) {
+    const routerFiles = findImportFiles(context.paths, (filePath) => /src\/server\/routers\/.+\.(ts|tsx|js|jsx)$/i.test(filePath))
+      .filter((filePath) => !/\/_app\.(ts|tsx|js|jsx)$/i.test(filePath) && !/\.test\./i.test(filePath));
+    const procedures = routerFiles.flatMap((filePath) => parseRouterProcedures(filePath, context.helpers.readTextIfExists(filePath) || ""));
+    const findings = [];
+    const candidates = { capabilities: [], routes: [], stacks: [] };
+    if (procedures.length > 0) {
+      findings.push({
+        kind: "trpc_procedures",
+        files: [...new Set(procedures.map((entry) => relativeTo(context.paths.repoRoot, entry.file)))],
+        capability_count: procedures.length
+      });
+      candidates.capabilities.push(...procedures.map((entry) => makeCandidateRecord({
+        kind: "capability",
+        idHint: entry.id_hint,
+        label: titleCase(entry.id_hint.replace(/^cap_/, "")),
+        confidence: "high",
+        sourceKind: "route_code",
+        provenance: `${relativeTo(context.paths.repoRoot, entry.file)}#${entry.routerName}.${entry.procedureName}`,
+        endpoint: entry.endpoint,
+        path_params: /\{id\}/.test(entry.endpoint.path) ? [{ name: "id", required: true, type: null }] : [],
+        query_params: [],
+        header_params: [],
+        input_fields: entry.input_fields,
+        output_fields: entry.output_fields,
+        auth_hint: entry.auth_hint,
+        entity_id: entry.entity_id,
+        track: "api"
+      })));
+      candidates.routes.push(...procedures.map((entry) => ({
+        path: entry.endpoint.path,
+        method: entry.endpoint.method,
+        confidence: "high",
+        source_kind: "route_code",
+        provenance: `${relativeTo(context.paths.repoRoot, entry.file)}#${entry.routerName}.${entry.procedureName}`
+      })));
+      candidates.stacks.push("trpc");
+    }
+    candidates.capabilities = dedupeCandidateRecords(candidates.capabilities, (record) => record.id_hint);
+    candidates.routes = dedupeCandidateRecords(
+      candidates.routes.map((route) => ({ ...route, id_hint: `${route.method}_${route.path}` })),
+      (record) => `${record.method}:${record.path}:${record.source_kind}`
+    ).map(({ id_hint, ...route }) => route);
+    candidates.stacks = [...new Set(candidates.stacks)].sort();
+    return { findings, candidates };
+  }
+};

package/src/import/extractors/db/django-models.js

@@ -0,0 +1,232 @@
+import path from "node:path";
+
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  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 classMatch = line.match(/^class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)\s*:/);
+    if (classMatch) {
+      if (current) {
+        blocks.push(current);
+      }
+      current = {
+        name: classMatch[1],
+        bases: classMatch[2],
+        lines: [line]
+      };
+      continue;
+    }
+    if (current) {
+      current.lines.push(line);
+    }
+  }
+
+  if (current) {
+    blocks.push(current);
+  }
+  return blocks;
+}
+
+function collectModelAssignments(lines) {
+  const assignments = [];
+  let current = null;
+  let balance = 0;
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+#.*$/, "");
+    if (!current) {
+      const match = line.match(/^\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*models\.([A-Za-z_][A-Za-z0-9_]*)\((.*)$/);
+      if (!match) continue;
+      current = {
+        fieldName: match[1],
+        fieldType: match[2],
+        raw: match[3]
+      };
+      balance = (match[3].match(/\(/g) || []).length - (match[3].match(/\)/g) || []).length + 1;
+      if (balance <= 0) {
+        assignments.push(current);
+        current = null;
+        balance = 0;
+      }
+      continue;
+    }
+
+    current.raw += `\n${line}`;
+    balance += (line.match(/\(/g) || []).length - (line.match(/\)/g) || []).length;
+    if (balance <= 0) {
+      assignments.push(current);
+      current = null;
+      balance = 0;
+    }
+  }
+
+  return assignments;
+}
+
+function extractRelatedModel(rawArgs, currentClassName) {
+  const quoted = String(rawArgs || "").match(/^\s*['"]([^'"]+)['"]/);
+  const bare = String(rawArgs || "").match(/^\s*([A-Za-z_][A-Za-z0-9_.]*)\s*(?:,|\))/);
+  const value = quoted?.[1] || bare?.[1] || null;
+  if (!value) return null;
+  if (value === "self") {
+    return currentClassName;
+  }
+  const modelName = value.split(".").pop();
+  return modelName || null;
+}
+
+function normalizeFieldType(fieldType, relatedModel) {
+  const normalized = String(fieldType || "").toLowerCase();
+  if (normalized === "charfield" || normalized === "textfield" || normalized === "slugfield" || normalized === "emailfield" || normalized === "urlfield") {
+    return "string";
+  }
+  if (normalized === "booleanfield") {
+    return "boolean";
+  }
+  if (normalized === "integerfield" || normalized === "autofield" || normalized === "bigintegerfield") {
+    return "int";
+  }
+  if (normalized === "datetimefield") {
+    return "datetime";
+  }
+  if (["foreignkey", "onetoonefield", "manytomanyfield"].includes(normalized) && relatedModel) {
+    return idHintify(relatedModel);
+  }
+  return normalized.replace(/field$/, "") || normalized;
+}
+
+function parseModelClass(block, provenance) {
+  const body = block.lines.join("\n");
+  if (/class\s+Meta\s*:[\s\S]*?abstract\s*=\s*True/.test(body)) {
+    return null;
+  }
+  const assignments = collectModelAssignments(block.lines.slice(1));
+  if (assignments.length === 0) {
+    return null;
+  }
+
+  const entityStem = canonicalCandidateTerm(block.name);
+  const entityId = `entity_${entityStem}`;
+  const fields = [];
+  const relations = [];
+
+  for (const assignment of assignments) {
+    const relatedModel = extractRelatedModel(assignment.raw, block.name);
+    const normalizedType = String(assignment.fieldType || "").toLowerCase();
+    const required = !/blank\s*=\s*True/.test(assignment.raw) && !/null\s*=\s*True/.test(assignment.raw);
+    const unique = /unique\s*=\s*True/.test(assignment.raw);
+    const list = normalizedType === "manytomanyfield";
+    const primaryKey = /primary_key\s*=\s*True/.test(assignment.raw);
+
+    fields.push({
+      name: assignment.fieldName,
+      field_type: normalizeFieldType(assignment.fieldType, relatedModel),
+      required,
+      list,
+      unique,
+      primary_key: primaryKey
+    });
+
+    if (["foreignkey", "onetoonefield", "manytomanyfield"].includes(normalizedType) && relatedModel) {
+      relations.push({
+        from_entity: entityId,
+        to_entity: `entity_${canonicalCandidateTerm(relatedModel)}`,
+        relation_field: assignment.fieldName,
+        fields: [assignment.fieldName],
+        references: ["id"],
+        relation_type: normalizedType
+      });
+    }
+  }
+
+  return {
+    entity: {
+      id_hint: entityId,
+      label: titleCase(entityStem),
+      model_name: block.name,
+      django_bases: block.bases.split(",").map((entry) => entry.trim()).filter(Boolean),
+      fields,
+      track: "db",
+      provenance
+    },
+    relations
+  };
+}
+
+export const djangoModelsExtractor = {
+  id: "db.django-models",
+  track: "db",
+  detect(context) {
+    const modelFiles = findImportFiles(context.paths, (filePath) => /\/models\.py$/i.test(filePath));
+    const manageFiles = findImportFiles(context.paths, (filePath) => /\/manage\.py$/i.test(filePath));
+    const score = modelFiles.length > 0 && manageFiles.length > 0 ? 91 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found Django manage.py and app models.py files"] : []
+    };
+  },
+  extract(context) {
+    const modelFiles = findImportFiles(context.paths, (filePath) => /\/models\.py$/i.test(filePath));
+    const findings = [];
+    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+
+    for (const filePath of modelFiles) {
+      const text = context.helpers.readTextIfExists(filePath) || "";
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const blocks = splitClassBlocks(text);
+      let entityCount = 0;
+
+      for (const block of blocks) {
+        const parsed = parseModelClass(block, provenance);
+        if (!parsed) continue;
+        entityCount += 1;
+        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,
+          django_bases: parsed.entity.django_bases,
+          fields: parsed.entity.fields,
+          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"
+        })));
+      }
+
+      if (entityCount > 0) {
+        findings.push({
+          kind: "django_models",
+          file: provenance,
+          entity_count: entityCount
+        });
+      }
+    }
+
+    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/dotnet-models.js

@@ -0,0 +1,93 @@
+import {
+  canonicalCandidateTerm,
+  dedupeCandidateRecords,
+  findImportFiles,
+  idHintify,
+  makeCandidateRecord,
+  relativeTo,
+  titleCase
+} from "../../core/shared.js";
+
+function normalizeCsType(typeName) {
+  const normalized = String(typeName || "").replace(/\?$/, "").trim();
+  switch (normalized.toLowerCase()) {
+    case "string": return "string";
+    case "int":
+    case "int32": return "int";
+    case "long":
+    case "int64": return "bigint";
+    case "bool":
+    case "boolean": return "boolean";
+    case "double": return "double";
+    case "float": return "float";
+    default: return idHintify(normalized) || "string";
+  }
+}
+
+function parseCsModel(text, provenance) {
+  const classMatch = String(text || "").match(/class\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?::\s*([A-Za-z0-9_, ]+))?\s*\{([\s\S]*?)\n\}/m);
+  if (!classMatch) return null;
+  const className = classMatch[1];
+  const body = classMatch[3];
+  const fields = [];
+  for (const match of body.matchAll(/public\s+([A-Za-z0-9_<>,?.]+)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{/g)) {
+    const [, typeName, name] = match;
+    const normalizedName = /^ID$/i.test(name) ? "id" : name.charAt(0).toLowerCase() + name.slice(1);
+    fields.push({
+      name: normalizedName,
+      field_type: normalizeCsType(typeName),
+      required: !String(typeName).includes("?"),
+      list: /^IEnumerable<|^List</.test(typeName),
+      unique: false,
+      primary_key: /^id$/i.test(name)
+    });
+  }
+  if (fields.length === 0) return null;
+  const stem = canonicalCandidateTerm(idHintify(className.replace(/([a-z0-9])([A-Z])/g, "$1_$2")));
+  return makeCandidateRecord({
+    kind: "entity",
+    idHint: `entity_${stem}`,
+    label: titleCase(stem),
+    confidence: "medium",
+    sourceKind: "schema",
+    provenance,
+    model_name: className,
+    fields,
+    track: "db"
+  });
+}
+
+export const dotnetModelsExtractor = {
+  id: "db.dotnet-models",
+  track: "db",
+  detect(context) {
+    const modelFiles = findImportFiles(context.paths, (filePath) => /\/Models\/.+\.cs$/i.test(filePath));
+    const csprojFiles = findImportFiles(context.paths, (filePath) => /\.csproj$/i.test(filePath));
+    const score = modelFiles.length > 0 && csprojFiles.length > 0 ? 78 : 0;
+    return {
+      score,
+      reasons: score > 0 ? ["Found .NET model classes in a project with .csproj"] : []
+    };
+  },
+  extract(context) {
+    const modelFiles = findImportFiles(context.paths, (filePath) => /\/Models\/.+\.cs$/i.test(filePath));
+    const findings = [];
+    const entities = [];
+    for (const filePath of modelFiles) {
+      const provenance = relativeTo(context.paths.repoRoot, filePath);
+      const entity = parseCsModel(context.helpers.readTextIfExists(filePath) || "", provenance);
+      if (!entity) continue;
+      entities.push(entity);
+      findings.push({ kind: "dotnet_model", file: provenance, entity_id: entity.id_hint });
+    }
+    return {
+      findings,
+      candidates: {
+        entities: dedupeCandidateRecords(entities, (record) => record.id_hint),
+        enums: [],
+        relations: [],
+        indexes: []
+      }
+    };
+  }
+};