@databricks-solutions/lakebase-scm-utils 0.2.50 → 0.3.0

package/dist/scripts/util/index.cjs

@@ -1667,8 +1667,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.2.50".length > 0) {
-    cached = "0.2.50";
+  if ("0.3.0".length > 0) {
+    cached = "0.3.0";
     return cached;
   }
   cached = "unknown";

package/dist/scripts/util/index.js

@@ -1630,8 +1630,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.2.50".length > 0) {
-    cached = "0.2.50";
+  if ("0.3.0".length > 0) {
+    cached = "0.3.0";
     return cached;
   }
   cached = "unknown";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@databricks-solutions/lakebase-scm-utils",
-  "version": "0.2.50",
+  "version": "0.3.0",
   "description": "Lakebase SCM + substrate engine: database branching, paired-branch SCM workflows, connection/credential minting, schema migration, project scaffold + deploy primitives, and the git/github utility layer. Extracted from consort for portable, standalone consumption by lakebase-scm-extension and the SFTDD orchestration.",
   "type": "module",
   "private": false,

package/scripts/lakebase/adapters/efcore-adapter.ts

@@ -0,0 +1,158 @@
+// EfCoreAdapter: SchemaMigrationAdapter implementation for .NET projects
+// using EF Core migrations.
+//
+// Wraps scripts/lakebase/schema-migrate-runners/efcore.ts in the cross-tool
+// adapter contract from ADR-0005. Supports rollback (EF generates Down()) and
+// stamp (writes "__EFMigrationsHistory" rows without running migrations).
+// collapseHeads is omitted: EF history is linear (flat-list, like Flyway).
+
+import * as path from "node:path";
+
+import { getConnection } from "../get-connection.js";
+import { findEfCoreProject, isDotnetProject } from "../dotnet-project.js";
+import {
+  applyEfcore,
+  createEfcoreMigration,
+  efDescription,
+  efVersion,
+  localEfMigrationIds,
+  rollbackEfcore,
+  stampEfcore,
+  statusEfcore,
+} from "../schema-migrate-runners/efcore.js";
+import type { AppliedSchemaMigration, PendingSchemaMigration, SchemaMigrationFile } from "../schema-migrate.js";
+import {
+  registerSchemaMigrationAdapter,
+  type ApplyArgs,
+  type ApplyResult,
+  type ListArgs,
+  type ListResult,
+  type NewMigrationArgs,
+  type NewMigrationResult,
+  type RollbackArgs,
+  type RollbackResult,
+  type SchemaMigrationAdapter,
+  type StampArgs,
+  type StampResult,
+  type StatusArgs,
+  type StatusResult,
+} from "../schema-migration-adapter.js";
+
+async function buildDsn(args: {
+  instance: string;
+  branch: string;
+  database?: string;
+  endpointName?: string;
+}): Promise<string> {
+  const result = await getConnection({
+    output: "dsn",
+    instance: args.instance,
+    branch: args.branch,
+    database: args.database,
+    endpointName: args.endpointName,
+  });
+  return result.url;
+}
+
+function errMsg(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+/** Migration files in apply order: Migrations/<timestamp>_<Name>.cs (not .Designer.cs / the snapshot). */
+export function listEfCoreFiles(projectDir: string): SchemaMigrationFile[] {
+  return localEfMigrationIds(projectDir).map((id) => ({
+    version: efVersion(id),
+    filename: `${id}.cs`,
+    description: efDescription(id),
+    type: "CSharp" as const,
+    tool: "efcore" as const,
+  }));
+}
+
+export const EfCoreAdapter: SchemaMigrationAdapter = {
+  id: "efcore",
+  languages: ["dotnet"],
+
+  /** A .NET project (root marker) with a *.csproj that references Microsoft.EntityFrameworkCore.Design. */
+  detect(projectDir: string): boolean {
+    return isDotnetProject(projectDir) && findEfCoreProject(projectDir) !== null;
+  },
+
+  async apply(args: ApplyArgs): Promise<ApplyResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const r = await applyEfcore({ projectDir: args.projectDir, dsn });
+      return {
+        applied_migrations: r.applied,
+        status: r.alreadyAtLatest ? "noop" : "ok",
+        tool_specific: { alreadyAtLatest: r.alreadyAtLatest, tool: r.tool },
+      };
+    } catch (err) {
+      return { applied_migrations: [], status: "error", error: errMsg(err) };
+    }
+  },
+
+  async rollback(args: RollbackArgs): Promise<RollbackResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const r = await rollbackEfcore({ projectDir: args.projectDir, dsn, target: args.target });
+      return {
+        rolled_back: r.rolledBack as AppliedSchemaMigration[],
+        status: r.rolledBack.length === 0 ? "noop" : "ok",
+        tool_specific: { tool: r.tool },
+      };
+    } catch (err) {
+      return { rolled_back: [], status: "error", error: errMsg(err) };
+    }
+  },
+
+  async stamp(args: StampArgs): Promise<StampResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const stamped = await stampEfcore({ projectDir: args.projectDir, dsn, revision: args.revision });
+      return { status: "ok", stamped_revision: stamped, tool_specific: { tool: "efcore" } };
+    } catch (err) {
+      return { status: "error", stamped_revision: null, error: errMsg(err) };
+    }
+  },
+
+  async status(args: StatusArgs): Promise<StatusResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const r = await statusEfcore({ projectDir: args.projectDir, dsn });
+      return {
+        applied_version: r.current ?? null,
+        pending: r.pending as PendingSchemaMigration[],
+        applied: [],
+        status: "ok",
+        tool_specific: { tool: r.tool },
+      };
+    } catch (err) {
+      return { applied_version: null, pending: [], applied: [], status: "error", error: errMsg(err) };
+    }
+  },
+
+  async list(args: ListArgs): Promise<ListResult> {
+    return { files: listEfCoreFiles(args.projectDir) };
+  },
+
+  // baseline: use stamp (EF has no separate baseline concept).
+
+  async newMigration(args: NewMigrationArgs): Promise<NewMigrationResult> {
+    // `dotnet ef migrations add` always generates from the model diff, so
+    // autogenerate is implicit and needs no database connection.
+    try {
+      const created = await createEfcoreMigration({ projectDir: args.projectDir, slug: args.slug });
+      return {
+        status: "ok",
+        version: efVersion(created.id),
+        filename: path.basename(created.path),
+        path: created.path,
+      };
+    } catch (err) {
+      return { status: "error", version: "", filename: "", path: "", error: errMsg(err) };
+    }
+  },
+};
+
+registerSchemaMigrationAdapter(EfCoreAdapter);

package/scripts/lakebase/adapters/flyway-adapter.ts

@@ -14,6 +14,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 import { getConnection } from "../get-connection.js";
+import { flywayMigrationsDir, isDotnetFlywayProject } from "../dotnet-project.js";
 import {
   applyFlyway,
   statusFlyway,
@@ -55,8 +56,9 @@ async function buildDsn(args: {
 }
 
 function listFlywayFiles(projectDir: string): SchemaMigrationFile[] {
-  // Flyway convention: src/main/resources/db/migration/V<n>__<desc>.sql
-  const dir = path.join(projectDir, "src", "main", "resources", "db", "migration");
+  // Flyway convention: V<n>__<desc>.sql under the Maven layout (Java/Kotlin)
+  // or db/migrations/ (.NET); see flywayMigrationsDir.
+  const dir = flywayMigrationsDir(projectDir);
   if (!fs.existsSync(dir)) return [];
   const files = fs.readdirSync(dir).filter((f) => /^V\d+(\.\d+)*__.+\.sql$/.test(f));
   return files
@@ -83,10 +85,11 @@ function versionCompare(a: string, b: string): number {
 
 export const FlywayAdapter: SchemaMigrationAdapter = {
   id: "flyway",
-  languages: ["java", "kotlin"],
+  languages: ["java", "kotlin", "dotnet"],
 
   detect(projectDir: string): boolean {
-    return fs.existsSync(path.join(projectDir, "pom.xml"));
+    // Maven project, or a .NET project that keeps Flyway SQL in db/migrations/.
+    return fs.existsSync(path.join(projectDir, "pom.xml")) || isDotnetFlywayProject(projectDir);
   },
 
   async apply(args: ApplyArgs): Promise<ApplyResult> {
@@ -155,7 +158,7 @@ export const FlywayAdapter: SchemaMigrationAdapter = {
     // so a flat Flyway list never collides across sibling branches. Flyway has
     // no DAG, so no merge-time head collapse is needed. autogenerate is ignored.
     try {
-      const dir = path.join(args.projectDir, "src", "main", "resources", "db", "migration");
+      const dir = flywayMigrationsDir(args.projectDir);
       fs.mkdirSync(dir, { recursive: true });
       const version = migrationTimestamp();
       const slug = migrationSlug(args.slug);

package/scripts/lakebase/collapse-heads.cli.ts

@@ -67,7 +67,7 @@ Usage:
 
 Flags:
   --project-dir <dir>  Project root (default: cwd)
-  --language <lang>    java | kotlin | python | nodejs (default: auto-detect)
+  --language <lang>    java | kotlin | python | nodejs | dotnet (default: auto-detect)
   --message, -m <txt>  Message for the merge revision (Alembic; default: "merge heads")
   --dry-run            Report the heads without creating a merge revision
   --pretty             Pretty-print JSON output

package/scripts/lakebase/create-project.ts

@@ -54,7 +54,7 @@ export interface ConsortSetupHooks {
       agentModels?: Record<string, string>;
       uiTrack?: boolean;
       clientFramework?: string;
-      language?: "java" | "kotlin" | "python" | "nodejs";
+      language?: "java" | "kotlin" | "python" | "nodejs" | "dotnet";
     },
   ): void;
 }
@@ -77,7 +77,9 @@ export interface CreateProjectArgs {
   /** Whether to make the GitHub repo private (default: true). */
   privateRepo?: boolean;
   /** Project language stack (default: 'java'). */
-  language?: "java" | "kotlin" | "python" | "nodejs";
+  language?: "java" | "kotlin" | "python" | "nodejs" | "dotnet";
+  /** .NET only: migration tool, "efcore" (default) or "flyway". */
+  migrationTool?: "efcore" | "flyway";
   /** CI runner type (default: 'self-hosted'). */
   runnerType?: "self-hosted" | "github-hosted";
   /**
@@ -257,9 +259,8 @@ export async function createProject(
     ? `${input.githubOwner}/${input.projectName}`
     : "";
 
-  // Upfront expectation: this is a one-time provision that takes a few minutes and
-  // does a lot. Say so, and name the genuinely-slow steps, so the wait doesn't look
-  // like a hang. (Each step below also reports as it runs.)
+  // State what the one-time provisioning creates up front; each step below reports as it
+  // runs. Say what is happening, not how long it takes (no duration/ETA/slow framing).
   {
     const usesGithub = !!input.githubOwner && input.createGithubRepo !== false;
     const tierCount = input.tiers ?? 1;
@@ -271,9 +272,8 @@ export async function createProject(
       tierCount > 1 ? `${tierCount} tiers (prod${tierCount >= 2 ? " + staging" : ""}${tierCount >= 3 ? " + dev" : ""})` : null,
     ].filter(Boolean);
     report(
-      `Setting up "${input.projectName}" , one-time provisioning, usually ~2-4 min. ` +
-        `This creates: ${bits.join(", ")}. ${usesGithub ? "The slowest part is the runner setup; that wait is normal. " : ""}` +
-        `Then the Consort toolkit downloads on first use (~1-2 min, one-time). Progress:`,
+      `Setting up "${input.projectName}". This creates: ${bits.join(", ")}. ` +
+        `The Consort toolkit downloads on first use. Progress:`,
     );
   }
 
@@ -342,7 +342,7 @@ export async function createProject(
   }
 
   // ── Step 3: Lakebase project ──────────────────────────────────
-  report("Creating Lakebase database (provisioning Postgres, ~30-60s)...", lakebaseProjectId);
+  report("Creating Lakebase database (provisioning Postgres)...", lakebaseProjectId);
   await createLakebaseProject({ projectId: lakebaseProjectId, host });
 
   // From here on the Lakebase project EXISTS. If any later step throws, roll it
@@ -367,6 +367,7 @@ export async function createProject(
     databricksHost: host,
     lakebaseProjectId,
     language,
+    migrationTool: input.migrationTool,
     runnerType,
     skipCommands,
     clientFramework,
@@ -457,7 +458,7 @@ export async function createProject(
 
   // ── Step 7: Self-hosted runner (GitHub + self-hosted only) ────
   if (useGithub && runnerType === "self-hosted") {
-    report("Setting up the self-hosted CI runner (downloads + registers it, ~1-2 min , the slow step)...");
+    report("Setting up the self-hosted CI runner: downloading, extracting, and registering it...");
     try {
       await setupRunner({
         fullRepoName,
@@ -572,8 +573,8 @@ export async function createProject(
       }
     }
     report(
-      "Consort toolkit downloads on first use (one-time, ~1-2 min) , run `./scripts/lk --refresh`, " +
-        "or just your first `./scripts/lk` command, and it installs then; instant afterward.",
+      "The Consort toolkit downloads on first use , run `./scripts/lk --refresh`, " +
+        "or just your first `./scripts/lk` command, and it installs then.",
     );
   }
 
@@ -583,6 +584,7 @@ export async function createProject(
     kotlin: "Kotlin/Spring Boot",
     python: "Python/FastAPI",
     nodejs: "Node.js/Express",
+    dotnet: `.NET/ASP.NET Core (${input.migrationTool === "flyway" ? "Flyway" : "EF Core"})`,
   };
   const langLabel = langLabels[language] ?? language;
   report("Creating initial commit...");

package/scripts/lakebase/detect-language.cli.ts

@@ -3,7 +3,7 @@
 // pr.yml + merge.yml to populate `steps.detect-lang.outputs.lang` without
 // duplicating the detection bash inline.
 //
-// Output: prints "java" | "python" | "nodejs" to stdout. Exits non-zero
+// Output: prints "java" | "kotlin" | "python" | "nodejs" | "dotnet" to stdout. Exits non-zero
 // if no recognised marker file is present.
 //
 // Optional flag: --project-dir <path> (defaults to cwd).
@@ -38,7 +38,7 @@ function printHelpAndExit(): never {
     `lakebase-detect-language – print the project's language\n\n` +
       `Usage:\n` +
       `  lakebase-detect-language [--project-dir <path>]\n\n` +
-      `Output (stdout): one of "java", "python", "nodejs"\n` +
+      `Output (stdout): one of "java", "kotlin", "python", "nodejs", "dotnet"\n` +
       `Exits 1 with an error message on stderr if no marker found.\n`,
   );
   process.exit(0);

package/scripts/lakebase/doctor.ts

@@ -285,6 +285,33 @@ async function checkPrereq(
   };
 }
 
+/** .NET SDK floor for `dotnet` projects (the scaffold targets net10.0). */
+const DOTNET_PREREQ: PrereqSpec = {
+  name: "dotnet-sdk",
+  cmd: "dotnet",
+  versionArgs: ["--version"],
+  minMajor: 10,
+  label: ".NET SDK",
+  hint: "Install the .NET 10 SDK (e.g. `brew install --cask dotnet-sdk` or https://dot.net). EF Core's dotnet-ef is restored per project from .config/dotnet-tools.json.",
+};
+
+/**
+ * Language-gated prerequisites: checked only when the project is that
+ * language, so a Java or Python user never sees a missing-.NET failure.
+ */
+export async function checkLanguagePrerequisites(
+  projectDir: string,
+  run: VersionRunner = defaultVersionRunner
+): Promise<CheckResult[]> {
+  let lang: string;
+  try {
+    lang = detectLanguage(projectDir);
+  } catch {
+    return [];
+  }
+  return lang === "dotnet" ? [await checkPrereq(DOTNET_PREREQ, run)] : [];
+}
+
 /** All cold-start prerequisite checks, in README order. */
 export async function checkPrerequisites(
   run: VersionRunner = defaultVersionRunner
@@ -712,6 +739,7 @@ export async function runDoctor(args: DoctorArgs = {}): Promise<DoctorReport> {
   // Cold-start prerequisites (Node/Python/JDK/gh/npm): always run, they are
   // local-environment checks with no auth dependency.
   const prereqs = await checkPrerequisites();
+  const languagePrereqs = await checkLanguagePrerequisites(projectDir);
 
   // Lakebase-enabled probe: needs a reachable workspace, so gate on auth like
   // the identity + lakebase-project checks.
@@ -727,6 +755,7 @@ export async function runDoctor(args: DoctorArgs = {}): Promise<DoctorReport> {
   const checks: CheckResult[] = [
     cli,
     ...prereqs,
+    ...languagePrereqs,
     auth,
     identity,
     lakebaseEnabled,

package/scripts/lakebase/dotnet-project.ts

@@ -0,0 +1,112 @@
+// .NET project discovery shared by language detection, the Flyway adapter
+// (dotnet layout), and the EF Core adapter. Pure filesystem scans; no
+// `dotnet` invocation, so detection stays fast and runtime-light.
+//
+// Layout the kit scaffolds (templates/project/dotnet*):
+//   App.sln
+//   src/App/App.csproj            <- application project
+//   src/App/Migrations/           <- EF Core migrations (efcore variant)
+//   db/migrations/V1__*.sql       <- Flyway migrations (flyway variant)
+//   tests/App.Tests/App.Tests.csproj
+//
+// A .NET project is identified by a *.sln / *.slnx / *.csproj at the ROOT
+// (the same rule language detection uses, so the kit never half-recognizes a
+// repo). Once identified, the EF Core project may live up to two levels down
+// (src/<Name>/, <Name>/).
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** Package whose reference marks a project as the EF Core migrations owner. */
+export const EF_DESIGN_PACKAGE = "Microsoft.EntityFrameworkCore.Design";
+
+/** Flyway migrations directory for .NET projects (relative to the project root). */
+export const DOTNET_FLYWAY_DIR = path.join("db", "migrations");
+
+const SKIP_DIRS = new Set(["bin", "obj", "node_modules", ".git", "client", "tests", "test"]);
+
+function safeReaddir(dir: string): fs.Dirent[] {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+/** True when `dir` itself carries a .NET marker (*.sln, *.slnx, *.csproj). */
+export function hasDotnetMarker(dir: string): boolean {
+  return safeReaddir(dir).some(
+    (e) => e.isFile() && /\.(sln|slnx|csproj)$/i.test(e.name),
+  );
+}
+
+/**
+ * Find *.csproj files at the root and up to two directory levels below it,
+ * skipping build output and test folders. Sorted for deterministic results.
+ */
+export function findCsprojFiles(projectDir: string): string[] {
+  const found: string[] = [];
+  const walk = (dir: string, depth: number) => {
+    for (const e of safeReaddir(dir)) {
+      const full = path.join(dir, e.name);
+      if (e.isFile() && e.name.toLowerCase().endsWith(".csproj")) {
+        found.push(full);
+      } else if (e.isDirectory() && depth < 2 && !SKIP_DIRS.has(e.name.toLowerCase()) && !e.name.startsWith(".")) {
+        walk(full, depth + 1);
+      }
+    }
+  };
+  walk(projectDir, 0);
+  return found.sort();
+}
+
+export interface EfCoreProject {
+  /** Absolute path to the .csproj that references EF Core Design. */
+  csproj: string;
+  /** Directory containing the .csproj. */
+  projectDir: string;
+  /** Absolute path to the project's Migrations/ directory (may not exist yet). */
+  migrationsDir: string;
+}
+
+/** Locate the project that owns EF Core migrations, or null. */
+export function findEfCoreProject(projectDir: string): EfCoreProject | null {
+  for (const csproj of findCsprojFiles(projectDir)) {
+    let content = "";
+    try {
+      content = fs.readFileSync(csproj, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.includes(EF_DESIGN_PACKAGE)) {
+      const dir = path.dirname(csproj);
+      return { csproj, projectDir: dir, migrationsDir: path.join(dir, "Migrations") };
+    }
+  }
+  return null;
+}
+
+/** True for a .NET repo: a *.sln / *.slnx / *.csproj at the root. */
+export function isDotnetProject(projectDir: string): boolean {
+  return hasDotnetMarker(projectDir);
+}
+
+/** True for a .NET repo that uses Flyway SQL migrations under db/migrations/. */
+export function isDotnetFlywayProject(projectDir: string): boolean {
+  return isDotnetProject(projectDir) && fs.existsSync(path.join(projectDir, DOTNET_FLYWAY_DIR));
+}
+
+/** Maven/Spring Flyway layout (Java/Kotlin). */
+export const MAVEN_FLYWAY_DIR = path.join("src", "main", "resources", "db", "migration");
+
+/**
+ * Absolute Flyway migrations directory for a project: the Maven layout for
+ * Java/Kotlin (and as the historical default), or `db/migrations` for a .NET
+ * project that uses Flyway.
+ */
+export function flywayMigrationsDir(projectDir: string): string {
+  const maven = path.join(projectDir, MAVEN_FLYWAY_DIR);
+  if (fs.existsSync(maven) || fs.existsSync(path.join(projectDir, "pom.xml"))) return maven;
+  if (isDotnetFlywayProject(projectDir)) return path.join(projectDir, DOTNET_FLYWAY_DIR);
+  return maven;
+}

package/scripts/lakebase/index.ts

@@ -73,6 +73,7 @@ export * from "./workflow-drift.js";
 export * from "./spring-initializr.js";
 export * from "./uc-resources.js";
 export * from "./migration-layout.js";
+export * from "./dotnet-project.js";
 export {
   applySchemaMigrations,
   rollbackSchemaMigration,

package/scripts/lakebase/migration-layout.ts

@@ -11,17 +11,19 @@
 
 import * as fs from "fs";
 import * as path from "path";
+import { findEfCoreProject, hasDotnetMarker, isDotnetFlywayProject } from "./dotnet-project.js";
 
 /** Languages the kit knows how to detect. `unknown` maps to the Flyway
  *  defaults (the historical fallback) so callers never crash on an
  *  unrecognized layout. */
-export type MigrationLanguage = "java" | "kotlin" | "python" | "nodejs" | "unknown";
+export type MigrationLanguage = "java" | "kotlin" | "python" | "nodejs" | "dotnet" | "unknown";
 
 const MIGRATION_LANGUAGES: readonly MigrationLanguage[] = [
   "java",
   "kotlin",
   "python",
   "nodejs",
+  "dotnet",
   "unknown",
 ];
 
@@ -41,6 +43,9 @@ export const MIGRATION_DEFAULTS: Record<MigrationLanguage, MigrationDefaults> =
   kotlin: { path: "src/main/resources/db/migration", pattern: /^V\d+.*\.sql$/i, glob: "*.sql" },
   python: { path: "alembic/versions", pattern: /^[0-9a-f][\w]*.*\.py$/i, glob: "*.py" },
   nodejs: { path: "migrations", pattern: /^\d+.*\.(js|ts)$/i, glob: "*.{js,ts}" },
+  // .NET + Flyway; EF Core projects get their Migrations/ dir from
+  // resolveMigrationLayout (see DOTNET_EFCORE_DEFAULTS).
+  dotnet: { path: "db/migrations", pattern: /^V\d+.*\.sql$/i, glob: "*.sql" },
   unknown: { path: "src/main/resources/db/migration", pattern: /^V\d+.*\.sql$/i, glob: "*.sql" },
 };
 
@@ -70,6 +75,11 @@ export function detectLanguageAt(dir: string): MigrationLanguage {
   ) {
     return "python";
   }
+  // .NET before package.json: an ASP.NET repo may carry a package.json for
+  // front-end tooling, but a *.sln / *.csproj at the root is unambiguous.
+  if (hasDotnetMarker(dir)) {
+    return "dotnet";
+  }
   if (fs.existsSync(path.join(dir, "package.json"))) {
     return "nodejs";
   }
@@ -144,6 +154,37 @@ export function compileMigrationPattern(src?: string): RegExp | undefined {
   }
 }
 
+/** EF Core: Migrations/<timestamp>_<Name>.cs, excluding *.Designer.cs and the model snapshot. */
+export const DOTNET_EFCORE_DEFAULTS: MigrationDefaults = {
+  path: "Migrations",
+  pattern: /^\d{14}_(?!.*\.Designer\.cs$).+\.cs$/i,
+  glob: "*.cs",
+};
+
+// IDE callers resolve the layout on every refresh; .NET resolution scans and
+// reads *.csproj files, so cache it briefly per project root.
+const DOTNET_LAYOUT_TTL_MS = 5000;
+const dotnetLayoutCache = new Map<string, { at: number; value: MigrationDefaults }>();
+
+/** .NET defaults depend on the migration tool: Flyway (db/migrations) or EF Core. */
+function dotnetDefaults(projectDir?: string): MigrationDefaults {
+  if (!projectDir) return MIGRATION_DEFAULTS.dotnet;
+  const key = path.resolve(projectDir);
+  const hit = dotnetLayoutCache.get(key);
+  if (hit && Date.now() - hit.at < DOTNET_LAYOUT_TTL_MS) return hit.value;
+
+  let value = MIGRATION_DEFAULTS.dotnet;
+  if (!isDotnetFlywayProject(projectDir)) {
+    const ef = findEfCoreProject(projectDir);
+    if (ef) {
+      const rel = path.relative(projectDir, ef.migrationsDir).split(path.sep).join("/");
+      value = { ...DOTNET_EFCORE_DEFAULTS, path: rel };
+    }
+  }
+  dotnetLayoutCache.set(key, { at: Date.now(), value });
+  return value;
+}
+
 export interface ResolveMigrationLayoutArgs {
   /** Project root. */
   projectDir?: string;
@@ -175,7 +216,7 @@ export interface MigrationLayout {
 export function resolveMigrationLayout(args: ResolveMigrationLayoutArgs): MigrationLayout {
   const configuredMigrationPath = (args.migrationPath ?? "").trim();
   const language = resolveMigrationLanguage(args.projectDir, configuredMigrationPath, args.language);
-  const defaults = MIGRATION_DEFAULTS[language];
+  const defaults = language === "dotnet" ? dotnetDefaults(args.projectDir) : MIGRATION_DEFAULTS[language];
   return {
     language,
     migrationPath: configuredMigrationPath || defaults.path,

package/scripts/lakebase/new-migration.cli.ts

@@ -92,7 +92,7 @@ Usage:
 Flags:
   --name, -m <text>    Human description; slugified into the filename (required)
   --project-dir <dir>  Project root (default: cwd)
-  --language <lang>    java | kotlin | python | nodejs (default: auto-detect)
+  --language <lang>    java | kotlin | python | nodejs | dotnet (default: auto-detect)
   --autogenerate       Alembic only: diff models vs the branch DB to populate
                        the body (requires --instance + --branch)
   --instance <id>      Lakebase project id (only with --autogenerate)