@topogram/cli 0.3.74 → 0.3.76

package/src/import/extractors/cli/generic.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+import path from "node:path";
+
 import {
   findImportFiles,
   idHintify,
@@ -12,6 +14,7 @@ import {
 
 const CLI_SOURCE_PATTERN = /(^|\/)(bin|cli|command|commands|parser|help)(\/|[-_.A-Za-z0-9]*\.(?:js|mjs|cjs|ts))$/i;
 const JS_SOURCE_PATTERN = /\.(?:js|mjs|cjs|ts)$/i;
+const NON_AUTHORITATIVE_CLI_PATH_PATTERN = /(^|\/)(test|tests|__tests__|fixtures|fixture|expected|snapshots|snapshot|mock|mocks|candidates|docs-generated)(\/|$)|\.(?:test|spec)\.(?:js|mjs|cjs|ts)$/i;
 
 /**
  * @param {string} value
@@ -21,6 +24,18 @@ function normalizePath(value) {
   return value.replaceAll("\\", "/");
 }
 
+/**
+ * CLI import should prefer public command surfaces, not tests or fixture strings
+ * that happen to look like command help.
+ * @param {any} paths
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function isAuthoritativeCliSource(paths, filePath) {
+  const normalized = normalizePath(normalizeImportRelativePath(paths, filePath));
+  return !NON_AUTHORITATIVE_CLI_PATH_PATTERN.test(normalized);
+}
+
 /**
  * @param {string} commandId
  * @returns {string}
@@ -29,24 +44,44 @@ function capabilityIdForCommand(commandId) {
   return `cap_${idHintify(commandId)}`;
 }
 
+/**
+ * @param {string} rawLine
+ * @returns {{ text: string, terminalOutput: boolean }}
+ */
+function normalizePotentialHelpLine(rawLine) {
+  const trimmed = rawLine.trim();
+  const terminalOutput = /^(?:console\.(?:log|error|warn)|print)\(\s*["'`]/.test(trimmed) || /^echo\s+["'`]/.test(trimmed);
+  return {
+    terminalOutput,
+    text: trimmed
+      .replace(/^\s*(?:console\.(?:log|error|warn)\(|print\(|echo\s+)?["'`]*/, "")
+      .replace(/["'`),;]*\s*$/, "")
+      .trim()
+  };
+}
+
 /**
  * @param {string} text
+ * @param {Set<string>} binNames
  * @returns {string[]}
  */
-function extractUsageLines(text) {
+function extractUsageLines(text, binNames) {
   const lines = [];
   for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine
-      .replace(/^\s*(?:console\.log\(|print\(|echo\s+)?["'`]*/, "")
-      .replace(/["'`),;]*\s*$/, "")
-      .trim();
+    const { text: line, terminalOutput } = normalizePotentialHelpLine(rawLine);
     if (!line) continue;
     const usageMatch = line.match(/(?:^|\b)Usage:\s*(.+)$/i);
     if (usageMatch?.[1]) {
       lines.push(usageMatch[1].trim());
       continue;
     }
-    if (/^[a-zA-Z][\w.-]+(?:\s+[a-zA-Z][\w:-]+)+(?:\s|$)/.test(line) && /(?:--[a-zA-Z][\w:-]*|<[^>]+>|\[[^\]]+\])/.test(line)) {
+    const firstToken = line.split(/\s+/)[0];
+    if (
+      terminalOutput &&
+      (binNames.size === 0 || binNames.has(firstToken)) &&
+      /^[a-zA-Z][\w.-]+(?:\s+[a-zA-Z][\w:-]+)+(?:\s|$)/.test(line) &&
+      /(?:--[a-zA-Z][\w:-]*|<[^>]+>|\[[^\]]+\])/.test(line)
+    ) {
       lines.push(line);
     }
   }
@@ -167,19 +202,79 @@ function dedupeRecords(records, keyFn) {
 
 /**
  * @param {any} context
- * @returns {{ packageFiles: string[], sourceFiles: string[] }}
+ * @param {string[]} packageFiles
+ * @returns {{ binNames: Set<string>, binTargets: Set<string>, findings: any[], provenance: string[] }}
+ */
+function inspectPackageCliMetadata(context, packageFiles) {
+  const binNames = new Set();
+  const binTargets = new Set();
+  const findings = [];
+  const provenance = [];
+
+  for (const packagePath of packageFiles) {
+    const pkg = readJsonIfExists(packagePath);
+    if (!pkg) continue;
+    const relPath = normalizeImportRelativePath(context.paths, packagePath);
+    const bin = pkg.bin;
+    if (typeof bin === "string") {
+      const binName = pkg.name ? String(pkg.name).split("/").pop() : "cli";
+      binNames.add(binName);
+      binTargets.add(path.resolve(path.dirname(packagePath), bin));
+      provenance.push(`${relPath}#bin`);
+    } else if (bin && typeof bin === "object") {
+      for (const [name, target] of Object.entries(bin)) {
+        binNames.add(name);
+        if (typeof target === "string") {
+          binTargets.add(path.resolve(path.dirname(packagePath), target));
+        }
+      }
+      provenance.push(`${relPath}#bin`);
+    }
+    for (const [name, command] of Object.entries(pkg.scripts || {})) {
+      if (/^(cli|bin|start|check|test|verify)(:|$)/.test(name) || /\b(node|tsx|ts-node)\b.+\b(cli|bin)\b/i.test(String(command))) {
+        findings.push({
+          kind: "cli_script",
+          name,
+          command,
+          source: relPath
+        });
+      }
+    }
+  }
+
+  return { binNames, binTargets, findings, provenance };
+}
+
+/**
+ * @param {any} context
+ * @returns {{ packageFiles: string[], sourceFiles: string[], binNames: Set<string>, findings: any[], provenance: string[] }}
  */
 function discoverCliSources(context) {
   const packageFiles = findImportFiles(context.paths, (/** @type {string} */ filePath) => /package\.json$/i.test(filePath));
+  const packageMetadata = inspectPackageCliMetadata(context, packageFiles);
   const sourceFiles = findImportFiles(context.paths, (/** @type {string} */ filePath) => {
     const normalized = normalizePath(filePath);
+    if (!isAuthoritativeCliSource(context.paths, filePath)) {
+      return false;
+    }
     return JS_SOURCE_PATTERN.test(normalized) && (
       CLI_SOURCE_PATTERN.test(normalized) ||
       normalized.includes("/src/cli/") ||
       normalized.includes("/commands/")
     );
   });
-  return { packageFiles, sourceFiles };
+  for (const binTarget of packageMetadata.binTargets) {
+    if (JS_SOURCE_PATTERN.test(binTarget)) {
+      sourceFiles.push(binTarget);
+    }
+  }
+  return {
+    packageFiles,
+    sourceFiles: [...new Set(sourceFiles)].sort(),
+    binNames: packageMetadata.binNames,
+    findings: packageMetadata.findings,
+    provenance: packageMetadata.provenance
+  };
 }
 
 export const genericCliExtractor = {
@@ -187,7 +282,7 @@ export const genericCliExtractor = {
   track: "cli",
   /** @param {any} context */
   detect(context) {
-    const { packageFiles, sourceFiles } = discoverCliSources(context);
+    const { packageFiles, sourceFiles, binNames } = discoverCliSources(context);
     const hasBin = packageFiles.some((filePath) => {
       const pkg = readJsonIfExists(filePath);
       return Boolean(pkg?.bin);
@@ -196,53 +291,25 @@ export const genericCliExtractor = {
     return {
       score,
       reasons: [
-        hasBin ? "package.json declares a CLI bin" : null,
+        hasBin ? `package.json declares ${binNames.size || 1} CLI bin${binNames.size === 1 ? "" : "s"}` : null,
         sourceFiles.length ? `${sourceFiles.length} CLI-like source files found` : null
       ].filter(Boolean)
     };
   },
   /** @param {any} context */
   extract(context) {
-    const { packageFiles, sourceFiles } = discoverCliSources(context);
-    const findings = [];
+    const { sourceFiles, binNames, findings, provenance } = discoverCliSources(context);
     const commands = [];
     const options = [];
     const outputs = [];
     const effects = [];
     const examples = [];
     const capabilities = [];
-    const binNames = new Set();
-    const provenance = [];
-
-    for (const packagePath of packageFiles) {
-      const pkg = readJsonIfExists(packagePath);
-      if (!pkg) continue;
-      const relPath = normalizeImportRelativePath(context.paths, packagePath);
-      const bin = pkg.bin;
-      if (typeof bin === "string") {
-        binNames.add(pkg.name ? String(pkg.name).split("/").pop() : "cli");
-      } else if (bin && typeof bin === "object") {
-        for (const name of Object.keys(bin)) {
-          binNames.add(name);
-        }
-      }
-      for (const [name, command] of Object.entries(pkg.scripts || {})) {
-        if (/^(cli|bin|start|check|test|verify)(:|$)/.test(name) || /\b(node|tsx|ts-node)\b.+\b(cli|bin)\b/i.test(String(command))) {
-          findings.push({
-            kind: "cli_script",
-            name,
-            command,
-            source: relPath
-          });
-        }
-      }
-      provenance.push(`${relPath}#bin`);
-    }
 
     for (const sourcePath of sourceFiles) {
       const sourceText = readTextIfExists(sourcePath) || "";
       const relPath = normalizeImportRelativePath(context.paths, sourcePath);
-      const usageLines = extractUsageLines(sourceText);
+      const usageLines = extractUsageLines(sourceText, binNames);
       if (usageLines.length === 0) {
         continue;
       }

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

@@ -10,6 +10,7 @@ import {
   slugify,
   titleCase
 } from "../../core/shared.js";
+import { inferDrizzleMaintainedDbSeams } from "./maintained-seams.js";
 
 function splitTopLevelEntries(block) {
   const entries = [];
@@ -165,21 +166,50 @@ function parseDrizzleTables(schemaText) {
   };
 }
 
+function drizzleConfigFiles(context) {
+  return findImportFiles(context.paths, (filePath) => /drizzle\.config\.(ts|js|mjs|cjs)$/i.test(path.basename(filePath)));
+}
+
+function configuredSchemaFiles(context, configFiles) {
+  const files = [];
+  for (const configFile of configFiles) {
+    const configText = context.helpers.readTextIfExists(configFile) || "";
+    for (const match of configText.matchAll(/\bschema\s*:\s*["'`]([^"'`*]+)["'`]/g)) {
+      const absoluteSchemaPath = path.resolve(path.dirname(configFile), match[1]);
+      if (context.helpers.readTextIfExists(absoluteSchemaPath) !== null) {
+        files.push(absoluteSchemaPath);
+      }
+    }
+  }
+  return files;
+}
+
+function findDrizzleSchemaFiles(context) {
+  const configFiles = drizzleConfigFiles(context);
+  const conventionalSchemaFiles = findImportFiles(context.paths, (filePath) =>
+    /(?:^|\/)(?:src\/db\/schema|src\/schema|db\/schema|schema)\.(ts|js|mjs|cjs)$/i.test(relativeTo(context.paths.workspaceRoot, filePath).replaceAll(path.sep, "/"))
+  );
+  return [...new Set([
+    ...configuredSchemaFiles(context, configFiles),
+    ...conventionalSchemaFiles
+  ])].sort();
+}
+
 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;
+    const hasConfig = drizzleConfigFiles(context).length > 0;
+    const hasSchema = findDrizzleSchemaFiles(context).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 schemaFiles = findDrizzleSchemaFiles(context);
     const findings = [];
-    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    const candidates = { entities: [], enums: [], relations: [], indexes: [], maintained_seams: [] };
     for (const filePath of schemaFiles) {
       const parsed = parseDrizzleTables(context.helpers.readTextIfExists(filePath) || "");
       const provenance = relativeTo(context.paths.repoRoot, filePath);
@@ -237,6 +267,7 @@ export const drizzleExtractor = {
     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);
+    candidates.maintained_seams = inferDrizzleMaintainedDbSeams(context, schemaFiles);
     return { findings, candidates };
   }
 };

package/src/import/extractors/db/maintained-seams.js

@@ -0,0 +1,208 @@
+// @ts-check
+
+import path from "node:path";
+
+import { findImportFiles, makeCandidateRecord, relativeTo } from "../../core/shared.js";
+
+/** @param {string} value @returns {string} */
+function toPosix(value) {
+  return String(value || "").replaceAll(path.sep, "/");
+}
+
+/** @param {any} context @param {string} filePath @returns {string} */
+function appRelativePath(context, filePath) {
+  return toPosix(relativeTo(context.paths.workspaceRoot, filePath));
+}
+
+/** @param {any} context @param {string} filePath @returns {string} */
+function evidencePath(context, filePath) {
+  return toPosix(relativeTo(context.paths.repoRoot, filePath));
+}
+
+/** @param {string} relativePath @param {string[]} segments @returns {string|null} */
+function prefixThroughSegments(relativePath, segments) {
+  const parts = toPosix(relativePath).split("/");
+  for (let index = 0; index <= parts.length - segments.length; index += 1) {
+    if (segments.every((segment, offset) => parts[index + offset] === segment)) {
+      return parts.slice(0, index + segments.length).join("/");
+    }
+  }
+  return null;
+}
+
+/** @param {string} relativePath @returns {string|null} */
+function migrationDirectoryFromRelativePath(relativePath) {
+  return prefixThroughSegments(relativePath, ["migrations"]) ||
+    prefixThroughSegments(relativePath, ["migration"]);
+}
+
+/** @param {any} context @param {string[]} files @param {string[][]} markers @returns {string|null} */
+function firstMarkedDirectory(context, files, markers) {
+  const directories = new Set();
+  for (const filePath of files) {
+    const relativePath = appRelativePath(context, filePath);
+    for (const marker of markers) {
+      const directory = prefixThroughSegments(relativePath, marker);
+      if (directory) {
+        directories.add(directory);
+      }
+    }
+  }
+  return [...directories].sort()[0] || null;
+}
+
+/** @param {any} context @param {string[]} configFiles @returns {string|null} */
+function drizzleOutPathFromConfig(context, configFiles) {
+  for (const configFile of configFiles.sort()) {
+    const configText = context.helpers.readTextIfExists(configFile) || "";
+    const outMatch = configText.match(/\bout\s*:\s*["'`]([^"'`]+)["'`]/);
+    if (!outMatch) {
+      continue;
+    }
+    const absoluteOut = path.resolve(path.dirname(configFile), outMatch[1]);
+    const relativeOut = appRelativePath(context, absoluteOut);
+    if (relativeOut && !relativeOut.startsWith("..")) {
+      return relativeOut;
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {any} context
+ * @param {{ tool: "sql"|"prisma"|"drizzle", schemaPath?: string|null, migrationsPath?: string|null, evidence: string[], matchReasons: string[], missingDecisions: string[] }} options
+ * @returns {any}
+ */
+function maintainedDbSeamCandidate(context, options) {
+  const runtimeId = "app_db";
+  const projectionId = "proj_db";
+  const snapshotPath = `topo/state/db/${runtimeId}/current.snapshot.json`;
+  const proposedRuntimeMigration = {
+    ownership: "maintained",
+    tool: options.tool,
+    apply: "never",
+    snapshotPath,
+    ...(options.schemaPath ? { schemaPath: options.schemaPath } : {}),
+    ...(options.migrationsPath ? { migrationsPath: options.migrationsPath } : {})
+  };
+  const idHint = `seam_${options.tool}_db_migrations`;
+
+  return makeCandidateRecord({
+    kind: "maintained_db_migration_seam",
+    idHint,
+    label: `${options.tool.toUpperCase()} maintained database migrations`,
+    confidence: options.missingDecisions.length === 0 ? "high" : "medium",
+    sourceKind: "migration_strategy_inference",
+    sourceOfTruth: "candidate",
+    provenance: options.evidence,
+    track: "db",
+    seam_id: idHint,
+    output_id: "maintained_app",
+    ownership_class: "human_owned",
+    status: "review_required",
+    tool: options.tool,
+    ownership: "maintained",
+    apply: "never",
+    schemaPath: options.schemaPath || null,
+    migrationsPath: options.migrationsPath || null,
+    snapshotPath,
+    runtime_id_hint: runtimeId,
+    projection_id_hint: projectionId,
+    evidence: options.evidence,
+    match_reasons: options.matchReasons,
+    missing_decisions: options.missingDecisions,
+    proposed_runtime_migration: proposedRuntimeMigration,
+    maintained_modules: [options.schemaPath, options.migrationsPath].filter(Boolean),
+    emitted_dependencies: [snapshotPath, projectionId],
+    allowed_change_classes: ["proposal_only"],
+    drift_signals: ["schema_or_migration_changed", "migration_directory_changed"]
+  });
+}
+
+/** @param {any} context @param {string[]} prismaFiles @returns {any[]} */
+export function inferPrismaMaintainedDbSeams(context, prismaFiles) {
+  if (!prismaFiles.length) {
+    return [];
+  }
+  const schemaPath = appRelativePath(context, prismaFiles[0]);
+  const migrationFiles = /** @type {string[]} */ (findImportFiles(context.paths, /** @param {string} filePath */ (filePath) => toPosix(filePath).includes("/prisma/migrations/")));
+  const migrationsPath = firstMarkedDirectory(context, migrationFiles, [["prisma", "migrations"]]);
+  return [
+    maintainedDbSeamCandidate(context, {
+      tool: "prisma",
+      schemaPath,
+      migrationsPath,
+      evidence: [
+        ...prismaFiles.map((filePath) => evidencePath(context, filePath)),
+        ...migrationFiles.slice(0, 3).map(/** @param {string} filePath */ (filePath) => evidencePath(context, filePath))
+      ],
+      matchReasons: [
+        "found Prisma schema",
+        ...(migrationsPath ? ["found Prisma migrations directory"] : [])
+      ],
+      missingDecisions: migrationsPath ? [] : ["confirm Prisma migrationsPath before adding this strategy to topogram.project.json"]
+    })
+  ];
+}
+
+/** @param {any} context @param {string[]} schemaFiles @returns {any[]} */
+export function inferDrizzleMaintainedDbSeams(context, schemaFiles) {
+  if (!schemaFiles.length) {
+    return [];
+  }
+  const configFiles = /** @type {string[]} */ (findImportFiles(context.paths, /** @param {string} filePath */ (filePath) => /drizzle\.config\.(ts|js|mjs|cjs)$/i.test(path.basename(filePath))));
+  const drizzleFiles = /** @type {string[]} */ (findImportFiles(context.paths, /** @param {string} filePath */ (filePath) => appRelativePath(context, filePath).startsWith("drizzle/")));
+  const configuredOutPath = drizzleOutPathFromConfig(context, configFiles);
+  const migrationsPath = configuredOutPath ||
+    firstMarkedDirectory(context, drizzleFiles, [["drizzle"]]);
+  return [
+    maintainedDbSeamCandidate(context, {
+      tool: "drizzle",
+      schemaPath: appRelativePath(context, schemaFiles[0]),
+      migrationsPath,
+      evidence: [
+        ...schemaFiles.map((filePath) => evidencePath(context, filePath)),
+        ...configFiles.map(/** @param {string} filePath */ (filePath) => evidencePath(context, filePath)),
+        ...drizzleFiles.slice(0, 3).map(/** @param {string} filePath */ (filePath) => evidencePath(context, filePath))
+      ],
+      matchReasons: [
+        "found Drizzle schema source",
+        ...(configFiles.length ? ["found Drizzle config"] : []),
+        ...(migrationsPath ? ["found Drizzle migrations output"] : [])
+      ],
+      missingDecisions: migrationsPath ? [] : ["confirm Drizzle migrationsPath before adding this strategy to topogram.project.json"]
+    })
+  ];
+}
+
+/** @param {any} context @param {string[]} allSqlFiles @param {string[]} selectedSqlFiles @returns {any[]} */
+export function inferSqlMaintainedDbSeams(context, allSqlFiles, selectedSqlFiles) {
+  if (!allSqlFiles.length) {
+    return [];
+  }
+  const schemaFile = selectedSqlFiles.find((filePath) => !/migration/i.test(path.basename(filePath))) ||
+    allSqlFiles.find((filePath) => /schema/i.test(path.basename(filePath))) ||
+    null;
+  const migrationFiles = allSqlFiles.filter((filePath) => {
+    const relativePath = appRelativePath(context, filePath);
+    return Boolean(migrationDirectoryFromRelativePath(relativePath)) || /migration/i.test(path.basename(filePath));
+  });
+  const migrationsPath = firstMarkedDirectory(context, migrationFiles, [["migrations"], ["migration"]]) ||
+    (migrationFiles.length ? toPosix(path.dirname(appRelativePath(context, migrationFiles[0]))) : null);
+  return [
+    maintainedDbSeamCandidate(context, {
+      tool: "sql",
+      schemaPath: schemaFile ? appRelativePath(context, schemaFile) : null,
+      migrationsPath,
+      evidence: [
+        ...(schemaFile ? [evidencePath(context, schemaFile)] : []),
+        ...migrationFiles.slice(0, 3).map((filePath) => evidencePath(context, filePath))
+      ],
+      matchReasons: [
+        ...(schemaFile ? ["found SQL schema"] : []),
+        ...(migrationsPath ? ["found SQL migrations directory or migration file"] : [])
+      ],
+      missingDecisions: migrationsPath ? [] : ["confirm SQL migrationsPath before adding this strategy to topogram.project.json"]
+    })
+  ];
+}

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

@@ -8,6 +8,7 @@ import {
   titleCase,
   idHintify
 } from "../../core/shared.js";
+import { inferPrismaMaintainedDbSeams } from "./maintained-seams.js";
 
 function parsePrismaSchema(schemaText) {
   const enums = [];
@@ -125,7 +126,7 @@ export const prismaExtractor = {
       "prisma"
     );
     const findings = [];
-    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    const candidates = { entities: [], enums: [], relations: [], indexes: [], maintained_seams: [] };
     for (const filePath of prismaFiles) {
       const parsed = parsePrismaSchema(context.helpers.readTextIfExists(filePath) || "");
       const provenance = relativeTo(context.paths.repoRoot, filePath);
@@ -179,7 +180,7 @@ export const prismaExtractor = {
         track: "db"
       })));
     }
+    candidates.maintained_seams = inferPrismaMaintainedDbSeams(context, prismaFiles);
     return { findings, candidates };
   }
 };
-

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

@@ -1,4 +1,5 @@
 import { canonicalCandidateTerm, findImportFiles, makeCandidateRecord, relativeTo, selectPreferredImportFiles, slugify, titleCase, idHintify } from "../../core/shared.js";
+import { inferSqlMaintainedDbSeams } from "./maintained-seams.js";
 
 function parseTableConstraint(line, tableName) {
   const normalized = line.replace(/,$/, "").trim();
@@ -119,7 +120,7 @@ export const sqlExtractor = {
         ? selectPreferredImportFiles(context.paths, schemaSqlFiles, "sql")
         : selectPreferredImportFiles(context.paths, migrationSqlFiles, "sql");
     const findings = [];
-    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    const candidates = { entities: [], enums: [], relations: [], indexes: [], maintained_seams: [] };
     for (const filePath of sqlFiles) {
       const parsed = parseSqlSchema(context.helpers.readTextIfExists(filePath) || "");
       const provenance = relativeTo(context.paths.repoRoot, filePath);
@@ -175,6 +176,7 @@ export const sqlExtractor = {
         track: "db"
       })));
     }
+    candidates.maintained_seams = inferSqlMaintainedDbSeams(context, allSqlFiles, sqlFiles);
     return { findings, candidates };
   }
 };