@vibgrate/cli 2026.711.2 → 2026.715.1

package/dist/{chunk-4IHO6VUL.js → chunk-6DKWB2OI.js}

@@ -1,10 +1,11 @@
-import { runCoreScan, writeJsonFile, compactUiPurpose } from './chunk-NNU2PW2H.js';
+import { runCoreScan, writeJsonFile, compactUiPurpose } from './chunk-C5AVF7PT.js';
 import { findPackageJsonFiles, readJsonFile, findFiles, readTextFile, pathExists } from './chunk-GI6W53LM.js';
 import * as path3 from 'path';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import * as semver from 'semver';
 import * as fs from 'fs/promises';
+import ts2 from 'typescript';
 
 var NATIVE_MODULE_PACKAGES = /* @__PURE__ */ new Set([
   // Image / media processing
@@ -2846,6 +2847,612 @@ function visitEach(node, cb) {
   node.forEachChild(cb);
 }
 
+// src/reporting/scanners/database-schema-sql.ts
+var CREDENTIAL_URL_RE = /:\/\/[^/\s'"]*:[^/\s'"]*@/;
+function stripCredentialLines(sql) {
+  return sql.split("\n").map((line) => CREDENTIAL_URL_RE.test(line) ? "" : line).join("\n");
+}
+var TABLE_LEVEL_KEYWORDS = /* @__PURE__ */ new Set(["PRIMARY", "FOREIGN", "CONSTRAINT", "UNIQUE", "CHECK", "INDEX", "KEY"]);
+var CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
+  "NOT",
+  "NULL",
+  "DEFAULT",
+  "PRIMARY",
+  "UNIQUE",
+  "REFERENCES",
+  "CHECK",
+  "CONSTRAINT",
+  "GENERATED",
+  "IDENTITY",
+  "AUTO_INCREMENT",
+  "AUTOINCREMENT",
+  "COLLATE",
+  "ON",
+  "COMMENT",
+  "ENCODE",
+  "DISTKEY",
+  "SORTKEY",
+  "WITH"
+]);
+function cleanIdentifier(raw) {
+  const parts = raw.split(".");
+  const last = (parts[parts.length - 1] ?? raw).trim();
+  return last.replace(/^[["'`]+/, "").replace(/[\]"'`;]+$/, "").trim();
+}
+function extractBalanced(sql, openParenIdx) {
+  let depth = 0;
+  for (let i = openParenIdx; i < sql.length; i++) {
+    if (sql[i] === "(") depth++;
+    else if (sql[i] === ")") {
+      depth--;
+      if (depth === 0) return sql.slice(openParenIdx + 1, i);
+    }
+  }
+  return null;
+}
+function splitTopLevel(body) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of body) {
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  return parts.map((s) => s.trim()).filter(Boolean);
+}
+function tokenize(def) {
+  const tokens = [];
+  const re = /[^\s(]+\([^)]*\)|[^\s]+/g;
+  let m;
+  while ((m = re.exec(def)) !== null) tokens.push(m[0]);
+  return tokens;
+}
+function containsSeq(tokens, seq) {
+  for (let i = 0; i + seq.length <= tokens.length; i++) {
+    if (seq.every((s, j) => tokens[i + j] === s)) return true;
+  }
+  return false;
+}
+function parseColumnDef(def) {
+  const tokens = tokenize(def);
+  if (tokens.length < 2) return null;
+  const first = tokens[0].toUpperCase();
+  if (TABLE_LEVEL_KEYWORDS.has(first)) return null;
+  const name = cleanIdentifier(tokens[0]);
+  if (!name) return null;
+  const rest = tokens.slice(1);
+  const typeTokens = [];
+  for (const t of rest) {
+    if (CONSTRAINT_KEYWORDS.has(t.toUpperCase())) break;
+    typeTokens.push(t);
+  }
+  const type = typeTokens.join(" ").trim();
+  if (!type) return null;
+  const upperRest = rest.map((t) => t.toUpperCase());
+  const isPrimaryKey = containsSeq(upperRest, ["PRIMARY", "KEY"]);
+  const isNotNull = containsSeq(upperRest, ["NOT", "NULL"]);
+  const isUnique = upperRest.includes("UNIQUE");
+  const isReference = upperRest.includes("REFERENCES");
+  return {
+    name,
+    type,
+    isList: false,
+    isOptional: !isNotNull && !isPrimaryKey,
+    isRelation: isReference,
+    isId: isPrimaryKey,
+    isUnique
+  };
+}
+function parseCreateTableStatements(rawSql) {
+  const sql = stripCredentialLines(rawSql);
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const re = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z0-9_."[\]`]+)\s*\(/gi;
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const openParenIdx = re.lastIndex - 1;
+    const body = extractBalanced(sql, openParenIdx);
+    if (body === null) continue;
+    re.lastIndex = openParenIdx + body.length + 2;
+    const name = cleanIdentifier(m[1]);
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    const fields = [];
+    const fieldNames = /* @__PURE__ */ new Set();
+    for (const part of splitTopLevel(body)) {
+      const field = parseColumnDef(part);
+      if (field && !fieldNames.has(field.name)) {
+        fields.push(field);
+        fieldNames.add(field.name);
+      }
+    }
+    results.push({ name, fields });
+  }
+  return results;
+}
+var DRIZZLE_TABLE_FUNCS = /* @__PURE__ */ new Set(["pgTable", "mysqlTable", "sqliteTable"]);
+function collectDrizzleTableImportNames(sf) {
+  const names = /* @__PURE__ */ new Set();
+  for (const stmt of sf.statements) {
+    if (!ts2.isImportDeclaration(stmt)) continue;
+    const spec = stmt.moduleSpecifier;
+    if (!ts2.isStringLiteral(spec) || !spec.text.startsWith("drizzle-orm")) continue;
+    const clause = stmt.importClause;
+    if (!clause?.namedBindings || !ts2.isNamedImports(clause.namedBindings)) continue;
+    for (const el of clause.namedBindings.elements) {
+      const imported = (el.propertyName ?? el.name).text;
+      if (DRIZZLE_TABLE_FUNCS.has(imported)) names.add(el.name.text);
+    }
+  }
+  return names;
+}
+function propertyKeyName(name) {
+  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name)) return name.text;
+  return null;
+}
+function parseColumnBuilderExpr(colName, expr) {
+  let node = expr;
+  let builderName = null;
+  let isPrimaryKey = false;
+  let isNotNull = false;
+  let isUnique = false;
+  let isReference = false;
+  while (ts2.isCallExpression(node)) {
+    const callee = node.expression;
+    if (ts2.isIdentifier(callee)) {
+      builderName = callee.text;
+      break;
+    }
+    if (ts2.isPropertyAccessExpression(callee)) {
+      switch (callee.name.text) {
+        case "primaryKey":
+          isPrimaryKey = true;
+          break;
+        case "notNull":
+          isNotNull = true;
+          break;
+        case "unique":
+          isUnique = true;
+          break;
+        case "references":
+          isReference = true;
+          break;
+      }
+      node = callee.expression;
+      continue;
+    }
+    break;
+  }
+  if (!builderName) return null;
+  return {
+    name: colName,
+    type: builderName,
+    isList: false,
+    isOptional: !isNotNull && !isPrimaryKey,
+    isRelation: isReference,
+    isId: isPrimaryKey,
+    isUnique
+  };
+}
+function parseDrizzleTableCall(call) {
+  const [nameArg, columnsArg] = call.arguments;
+  if (!nameArg || !ts2.isStringLiteral(nameArg)) return null;
+  const fields = [];
+  if (columnsArg && ts2.isObjectLiteralExpression(columnsArg)) {
+    for (const prop of columnsArg.properties) {
+      if (!ts2.isPropertyAssignment(prop)) continue;
+      const colName = propertyKeyName(prop.name);
+      if (!colName) continue;
+      const field = parseColumnBuilderExpr(colName, prop.initializer);
+      if (field) fields.push(field);
+    }
+  }
+  return { name: nameArg.text, fields };
+}
+function parseDrizzleFile(sourceText, fileName) {
+  const sf = ts2.createSourceFile(fileName, sourceText, ts2.ScriptTarget.ES2022, true, ts2.ScriptKind.TSX);
+  const tableImportNames = collectDrizzleTableImportNames(sf);
+  if (tableImportNames.size === 0) return [];
+  const tables = [];
+  const visit = (node) => {
+    if (ts2.isCallExpression(node) && ts2.isIdentifier(node.expression) && tableImportNames.has(node.expression.text)) {
+      const table = parseDrizzleTableCall(node);
+      if (table) tables.push(table);
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(sf);
+  return tables;
+}
+var COLUMN_DECORATORS = /* @__PURE__ */ new Set(["Column", "PrimaryColumn", "PrimaryGeneratedColumn"]);
+var RELATION_DECORATORS = /* @__PURE__ */ new Set(["OneToMany", "ManyToOne", "ManyToMany", "OneToOne", "JoinColumn"]);
+var MANY_RELATION_DECORATORS = /* @__PURE__ */ new Set(["OneToMany", "ManyToMany"]);
+var ID_DECORATORS = /* @__PURE__ */ new Set(["PrimaryColumn", "PrimaryGeneratedColumn"]);
+function decoratorInfo(dec) {
+  const expr = dec.expression;
+  if (ts2.isCallExpression(expr) && ts2.isIdentifier(expr.expression)) {
+    return { name: expr.expression.text, args: expr.arguments };
+  }
+  if (ts2.isIdentifier(expr)) return { name: expr.text, args: [] };
+  return null;
+}
+function decoratorsOf(node) {
+  const decs = ts2.getDecorators(node) ?? [];
+  const out = [];
+  for (const d of decs) {
+    const info = decoratorInfo(d);
+    if (info) out.push(info);
+  }
+  return out;
+}
+function stringOrNamedArg(args, propName) {
+  const first = args[0];
+  if (!first) return null;
+  if (ts2.isStringLiteral(first)) return first.text;
+  if (ts2.isObjectLiteralExpression(first)) {
+    for (const prop of first.properties) {
+      if (ts2.isPropertyAssignment(prop) && ts2.isIdentifier(prop.name) && prop.name.text === propName && ts2.isStringLiteral(prop.initializer)) {
+        return prop.initializer.text;
+      }
+    }
+  }
+  return null;
+}
+function parseEntity(cls, entityDec) {
+  const tableName = stringOrNamedArg(entityDec.args, "name") ?? cls.name.text;
+  const fields = [];
+  for (const member of cls.members) {
+    if (!ts2.isPropertyDeclaration(member) || !ts2.isIdentifier(member.name)) continue;
+    const decNames = new Set(decoratorsOf(member).map((d) => d.name));
+    const isColumn = [...decNames].some((n) => COLUMN_DECORATORS.has(n));
+    const isRelation = [...decNames].some((n) => RELATION_DECORATORS.has(n));
+    if (!isColumn && !isRelation) continue;
+    fields.push({
+      name: member.name.text,
+      type: member.type ? member.type.getText() : "unknown",
+      isList: [...decNames].some((n) => MANY_RELATION_DECORATORS.has(n)),
+      isOptional: member.questionToken !== void 0,
+      isRelation,
+      isId: [...decNames].some((n) => ID_DECORATORS.has(n)),
+      isUnique: false
+    });
+  }
+  return { name: tableName, fields: fields.sort((a, b) => a.name.localeCompare(b.name)) };
+}
+function parseTypeOrmFile(sourceText, fileName) {
+  const sf = ts2.createSourceFile(fileName, sourceText, ts2.ScriptTarget.ES2022, true, ts2.ScriptKind.TS);
+  const entities = [];
+  const visit = (node) => {
+    if (ts2.isClassDeclaration(node) && node.name) {
+      const entityDec = decoratorsOf(node).find((d) => d.name === "Entity");
+      if (entityDec) entities.push(parseEntity(node, entityDec));
+    }
+    ts2.forEachChild(node, visit);
+  };
+  visit(sf);
+  return entities;
+}
+
+// src/reporting/scanners/database-schema.ts
+var SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "String",
+  "Int",
+  "Float",
+  "Boolean",
+  "DateTime",
+  "Json",
+  "Bytes",
+  "Decimal",
+  "BigInt"
+]);
+async function findPrismaFiles(rootDir, cache) {
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    return entries.filter((e) => e.isFile && e.name.endsWith(".prisma")).map((e) => e.absPath);
+  }
+  return findFiles(rootDir, (name) => name.endsWith(".prisma"));
+}
+function normalizeRel(relPath) {
+  return relPath.replace(/\\/g, "/");
+}
+function extractBlocks(raw, keyword) {
+  const re = new RegExp(`${keyword}\\s+(\\w+)\\s*\\{([^}]*)\\}`, "gs");
+  const blocks = [];
+  let match;
+  while ((match = re.exec(raw)) !== null) {
+    blocks.push({ name: match[1], body: match[2] });
+  }
+  return blocks;
+}
+function extractDatasourceProviders(raw) {
+  const providers = [];
+  for (const block of extractBlocks(raw, "datasource")) {
+    const m = block.body.match(/(?:^|\n)\s*provider\s*=\s*"([^"]+)"/);
+    if (m) providers.push(m[1]);
+  }
+  return providers;
+}
+function extractModels(raw) {
+  return extractBlocks(raw, "model").map((block) => ({
+    name: block.name,
+    fields: parseFieldLines(block.body)
+  }));
+}
+function extractEnums(raw) {
+  return extractBlocks(raw, "enum").map((block) => {
+    const values = [];
+    for (const line of block.body.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@@")) continue;
+      const token = trimmed.split(/\s+/)[0];
+      if (token) values.push(token);
+    }
+    return { name: block.name, values: [...new Set(values)].sort() };
+  });
+}
+function parseFieldLines(body) {
+  const fields = [];
+  for (const rawLine of body.split("\n")) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@@") || trimmed.startsWith("/*")) continue;
+    const tokens = trimmed.split(/\s+/);
+    if (tokens.length < 2) continue;
+    const [name, rawType] = tokens;
+    if (!/^\w+$/.test(name)) continue;
+    const attrs = [...trimmed.matchAll(/@(\w+)/g)].map((m) => m[1]);
+    fields.push({ name, rawType, attrs });
+  }
+  return fields;
+}
+function finalizeField(field, modelNames) {
+  const isList = field.rawType.includes("[]");
+  const isOptional = field.rawType.includes("?");
+  const baseType = field.rawType.replace(/\[\]/g, "").replace(/\?/g, "");
+  const isRelation = field.attrs.includes("relation") || !SCALAR_TYPES.has(baseType) && modelNames.has(baseType);
+  return {
+    name: field.name,
+    type: baseType,
+    isList,
+    isOptional,
+    isRelation,
+    isId: field.attrs.includes("id"),
+    isUnique: field.attrs.includes("unique")
+  };
+}
+function findOwningProject(fileRel, projects) {
+  let best;
+  let bestLen = -1;
+  for (const project of projects) {
+    const projPath = project.path === "." ? "" : normalizeRel(project.path).replace(/\/$/, "");
+    const matches = projPath === "" || fileRel === projPath || fileRel.startsWith(`${projPath}/`);
+    if (matches && projPath.length > bestLen) {
+      best = project;
+      bestLen = projPath.length;
+    }
+  }
+  return best;
+}
+function buildProjectBreakdown(projects, filesScanned, modelNamesByFile, enumNamesByFile) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const fileRel of filesScanned) {
+    const owner = findOwningProject(fileRel, projects);
+    const key = owner?.path ?? ".";
+    if (!byProject.has(key)) byProject.set(key, { files: /* @__PURE__ */ new Set(), models: /* @__PURE__ */ new Set(), enums: /* @__PURE__ */ new Set() });
+    const bucket = byProject.get(key);
+    bucket.files.add(fileRel);
+    for (const name of modelNamesByFile.get(fileRel) ?? []) bucket.models.add(name);
+    for (const name of enumNamesByFile.get(fileRel) ?? []) bucket.enums.add(name);
+  }
+  return [...byProject.entries()].map(([project, bucket]) => ({
+    project,
+    filesScanned: [...bucket.files].sort(),
+    models: [...bucket.models].sort(),
+    enums: [...bucket.enums].sort()
+  })).sort((a, b) => a.project.localeCompare(b.project));
+}
+async function scanPrismaSource(rootDir, cache) {
+  const filePaths = await findPrismaFiles(rootDir, cache);
+  const providers = /* @__PURE__ */ new Set();
+  const modelsByFile = /* @__PURE__ */ new Map();
+  const enumsByFile = /* @__PURE__ */ new Map();
+  const filesScanned = [];
+  for (const filePath of filePaths) {
+    let raw = "";
+    try {
+      raw = cache ? await cache.readTextFile(filePath) : await readTextFile(filePath);
+    } catch {
+      continue;
+    }
+    if (!raw.trim()) continue;
+    const rel = normalizeRel(path3.relative(rootDir, filePath));
+    filesScanned.push(rel);
+    for (const provider of extractDatasourceProviders(raw)) providers.add(provider);
+    modelsByFile.set(rel, extractModels(raw));
+    enumsByFile.set(rel, extractEnums(raw));
+  }
+  const modelNameSet = /* @__PURE__ */ new Set();
+  for (const models2 of modelsByFile.values()) {
+    for (const m of models2) modelNameSet.add(m.name);
+  }
+  const modelMap = /* @__PURE__ */ new Map();
+  for (const [fileRel, rawModels] of modelsByFile.entries()) {
+    for (const rawModel of rawModels) {
+      const fields = rawModel.fields.map((f) => finalizeField(f, modelNameSet));
+      const existing = modelMap.get(rawModel.name);
+      if (!existing) {
+        modelMap.set(rawModel.name, { name: rawModel.name, fields, files: /* @__PURE__ */ new Set([fileRel]) });
+        continue;
+      }
+      existing.files.add(fileRel);
+      const seen = new Set(existing.fields.map((f) => f.name));
+      for (const field of fields) {
+        if (!seen.has(field.name)) {
+          existing.fields.push(field);
+          seen.add(field.name);
+        }
+      }
+    }
+  }
+  const models = [...modelMap.values()].map((m) => ({
+    name: m.name,
+    fields: [...m.fields].sort((a, b) => a.name.localeCompare(b.name)),
+    source: "prisma",
+    files: [...m.files].sort()
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const enumMap = /* @__PURE__ */ new Map();
+  for (const enums2 of enumsByFile.values()) {
+    for (const e of enums2) {
+      if (!enumMap.has(e.name)) enumMap.set(e.name, e);
+    }
+  }
+  const enums = [...enumMap.values()].map((e) => ({ name: e.name, values: [...e.values].sort() })).sort((a, b) => a.name.localeCompare(b.name));
+  const enumNamesByFile = /* @__PURE__ */ new Map();
+  for (const [fileRel, es] of enumsByFile.entries()) {
+    enumNamesByFile.set(fileRel, new Set(es.map((e) => e.name)));
+  }
+  return { models, enums, providers: [...providers].sort(), filesScanned: filesScanned.sort(), enumNamesByFile };
+}
+function isSqlFile(name) {
+  return name.endsWith(".sql");
+}
+async function readFileSafely(filePath, cache) {
+  try {
+    return cache ? await cache.readTextFile(filePath) : await readTextFile(filePath);
+  } catch {
+    return null;
+  }
+}
+async function scanSqlSource(rootDir, filePaths, source, cache) {
+  const sortedPaths = [...filePaths].sort((a, b) => a.localeCompare(b));
+  const seenTables = /* @__PURE__ */ new Set();
+  const models = [];
+  const filesScanned = [];
+  for (const filePath of sortedPaths) {
+    const raw = await readFileSafely(filePath, cache);
+    if (raw == null || !raw.trim()) continue;
+    const tables = parseCreateTableStatements(raw);
+    if (tables.length === 0) continue;
+    const rel = normalizeRel(path3.relative(rootDir, filePath));
+    filesScanned.push(rel);
+    for (const t of tables) {
+      if (seenTables.has(t.name)) continue;
+      seenTables.add(t.name);
+      models.push({
+        name: t.name,
+        fields: [...t.fields].sort((a, b) => a.name.localeCompare(b.name)),
+        source,
+        files: [rel]
+      });
+    }
+  }
+  return { models: models.sort((a, b) => a.name.localeCompare(b.name)), filesScanned: filesScanned.sort() };
+}
+async function findSqlprojFiles(rootDir, cache) {
+  return cache ? cache.findFiles(rootDir, (name) => name.endsWith(".sqlproj")) : findFiles(rootDir, (name) => name.endsWith(".sqlproj"));
+}
+async function scanSqlprojSource(rootDir, cache) {
+  const sqlprojPaths = await findSqlprojFiles(rootDir, cache);
+  const sqlAbsPaths = /* @__PURE__ */ new Set();
+  for (const sqlprojPath of sqlprojPaths) {
+    const dir = path3.dirname(sqlprojPath);
+    const files = cache ? await cache.findFiles(dir, isSqlFile) : await findFiles(dir, isSqlFile);
+    for (const f of files) sqlAbsPaths.add(f);
+  }
+  const result = await scanSqlSource(rootDir, [...sqlAbsPaths], "sqlproj", cache);
+  return { ...result, sqlAbsPaths };
+}
+async function scanSqlMigrationsSource(rootDir, excludeAbsPaths, cache) {
+  const allSqlFiles = cache ? await cache.findFiles(rootDir, isSqlFile) : await findFiles(rootDir, isSqlFile);
+  const migrationFiles = allSqlFiles.filter((f) => !excludeAbsPaths.has(f));
+  return scanSqlSource(rootDir, migrationFiles, "sql-migration", cache);
+}
+function isTsSourceFile(name) {
+  return (name.endsWith(".ts") || name.endsWith(".tsx")) && !name.endsWith(".d.ts");
+}
+async function findTsSourceFiles(rootDir, cache) {
+  return cache ? cache.findFiles(rootDir, isTsSourceFile) : findFiles(rootDir, isTsSourceFile);
+}
+async function scanDrizzleSource(rootDir, cache) {
+  const filePaths = (await findTsSourceFiles(rootDir, cache)).sort((a, b) => a.localeCompare(b));
+  const seenTables = /* @__PURE__ */ new Set();
+  const models = [];
+  const filesScanned = [];
+  for (const filePath of filePaths) {
+    const raw = await readFileSafely(filePath, cache);
+    if (raw == null || !raw.includes("drizzle-orm")) continue;
+    const tables = parseDrizzleFile(raw, filePath);
+    if (tables.length === 0) continue;
+    const rel = normalizeRel(path3.relative(rootDir, filePath));
+    filesScanned.push(rel);
+    for (const t of tables) {
+      if (seenTables.has(t.name)) continue;
+      seenTables.add(t.name);
+      models.push({
+        name: t.name,
+        fields: [...t.fields].sort((a, b) => a.name.localeCompare(b.name)),
+        source: "drizzle",
+        files: [rel]
+      });
+    }
+  }
+  return { models: models.sort((a, b) => a.name.localeCompare(b.name)), filesScanned: filesScanned.sort() };
+}
+async function scanTypeOrmSource(rootDir, cache) {
+  const filePaths = (await findTsSourceFiles(rootDir, cache)).sort((a, b) => a.localeCompare(b));
+  const seenTables = /* @__PURE__ */ new Set();
+  const models = [];
+  const filesScanned = [];
+  for (const filePath of filePaths) {
+    const raw = await readFileSafely(filePath, cache);
+    if (raw == null || !raw.includes("@Entity")) continue;
+    const entities = parseTypeOrmFile(raw, filePath);
+    if (entities.length === 0) continue;
+    const rel = normalizeRel(path3.relative(rootDir, filePath));
+    filesScanned.push(rel);
+    for (const e of entities) {
+      if (seenTables.has(e.name)) continue;
+      seenTables.add(e.name);
+      models.push({ name: e.name, fields: e.fields, source: "typeorm", files: [rel] });
+    }
+  }
+  return { models: models.sort((a, b) => a.name.localeCompare(b.name)), filesScanned: filesScanned.sort() };
+}
+async function scanDatabaseSchema(rootDir, projects, cache) {
+  const prisma = await scanPrismaSource(rootDir, cache);
+  const sqlproj = await scanSqlprojSource(rootDir, cache);
+  const sqlMigrations = await scanSqlMigrationsSource(rootDir, sqlproj.sqlAbsPaths, cache);
+  const drizzle = await scanDrizzleSource(rootDir, cache);
+  const typeorm = await scanTypeOrmSource(rootDir, cache);
+  const models = [...prisma.models, ...sqlMigrations.models, ...sqlproj.models, ...drizzle.models, ...typeorm.models].sort(
+    (a, b) => a.name.localeCompare(b.name) || a.source.localeCompare(b.source)
+  );
+  if (models.length === 0 && prisma.enums.length === 0) return void 0;
+  const filesScanned = [
+    .../* @__PURE__ */ new Set([...prisma.filesScanned, ...sqlMigrations.filesScanned, ...sqlproj.filesScanned, ...drizzle.filesScanned, ...typeorm.filesScanned])
+  ].sort();
+  const modelNamesByFile = /* @__PURE__ */ new Map();
+  for (const m of models) {
+    for (const f of m.files) {
+      if (!modelNamesByFile.has(f)) modelNamesByFile.set(f, /* @__PURE__ */ new Set());
+      modelNamesByFile.get(f).add(m.name);
+    }
+  }
+  return {
+    providers: prisma.providers,
+    models,
+    enums: prisma.enums,
+    filesScanned,
+    projects: buildProjectBreakdown(projects, filesScanned, modelNamesByFile, prisma.enumNamesByFile)
+  };
+}
+
 // src/reporting/scanners/ui-purpose.ts
 var UI_EXTENSIONS = /* @__PURE__ */ new Set([
   ".tsx",
@@ -3494,7 +4101,8 @@ async function runAdvancedAnalysis(ctx) {
     tsModernity: !maxPrivacyMode,
     fileHotspots: !maxPrivacyMode,
     architecture: !maxPrivacyMode,
-    codeQuality: !maxPrivacyMode};
+    codeQuality: !maxPrivacyMode,
+    databaseSchema: !maxPrivacyMode};
   const advancedSteps = [
     ...scannerPolicy.platformMatrix && scanners?.platformMatrix?.enabled !== false ? [{ id: "platform", label: "Platform matrix" }] : [],
     ...scanners?.toolingInventory?.enabled !== false ? [{ id: "tooling", label: "Tooling inventory" }] : [],
@@ -3508,6 +4116,7 @@ async function runAdvancedAnalysis(ctx) {
     ...scanners?.dependencyRisk?.enabled !== false ? [{ id: "deprisk", label: "Dependency risk" }] : [],
     ...scannerPolicy.architecture && scanners?.architecture?.enabled !== false ? [{ id: "architecture", label: "Architecture layers" }] : [],
     ...scannerPolicy.codeQuality && scanners?.codeQuality?.enabled !== false ? [{ id: "codequality", label: "Code quality metrics" }] : [],
+    ...scannerPolicy.databaseSchema && scanners?.databaseSchema?.enabled !== false ? [{ id: "databaseschema", label: "Database schema" }] : [],
     ...!maxPrivacyMode && (opts.uiPurpose || scanners?.uiPurpose?.enabled === true) ? [{ id: "uipurpose", label: "UI purpose evidence" }] : []
   ];
   for (const step of advancedSteps) {
@@ -3630,6 +4239,20 @@ async function runAdvancedAnalysis(ctx) {
       })
     );
   }
+  if (scannerPolicy.databaseSchema && scanners?.databaseSchema?.enabled !== false) {
+    progress.startStep("databaseschema");
+    scannerTasks.push(
+      scanDatabaseSchema(rootDir, allProjects, fileCache).then((result) => {
+        extended.databaseSchema = result;
+        const modelCount = result?.models.length ?? 0;
+        const enumCount = result?.enums.length ?? 0;
+        const dsParts = [];
+        if (modelCount > 0) dsParts.push(`${modelCount} model${modelCount !== 1 ? "s" : ""}`);
+        if (enumCount > 0) dsParts.push(`${enumCount} enum${enumCount !== 1 ? "s" : ""}`);
+        progress.completeStep("databaseschema", dsParts.join(", ") || "none found", modelCount);
+      })
+    );
+  }
   if (scanners?.dependencyRisk?.enabled !== false) {
     progress.startStep("deprisk");
     scannerTasks.push(
@@ -3702,6 +4325,7 @@ async function runAdvancedAnalysis(ctx) {
     advancedFiles += extended.buildDeploy.ci.length;
   }
   if (extended.codeQuality) advancedFiles += extended.codeQuality.filesAnalyzed;
+  if (extended.databaseSchema) advancedFiles += extended.databaseSchema.filesScanned.length;
   if (extended.uiPurpose) advancedFiles += extended.uiPurpose.topEvidence.length;
   if (advancedFiles > 0) ctx.addFilesScanned(advancedFiles);
 }
@@ -3731,5 +4355,5 @@ var baselineCommand = new Command("baseline").description("Create a drift baseli
 });
 
 export { baselineCommand, loadAdvancedScanHook, runBaseline };
-//# sourceMappingURL=chunk-4IHO6VUL.js.map
-//# sourceMappingURL=chunk-4IHO6VUL.js.map
+//# sourceMappingURL=chunk-6DKWB2OI.js.map
+//# sourceMappingURL=chunk-6DKWB2OI.js.map