@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/efcore/cli/lib/detect-dbcontexts.ts

@@ -0,0 +1,195 @@
+/**
+ * detect-dbcontexts.ts — Discover EF Core DbContexts in a worktree.
+ *
+ * Strategy: find every *ModelSnapshot.cs, read its `partial class Xxx`
+ * declaration, then associate it with the .csproj that owns the snapshot's
+ * migrations folder. Multiple snapshots for the same context (across
+ * Migrations.Sqlite / Postgres / SqlServer assemblies) are grouped as one
+ * context with multiple "assemblies".
+ *
+ * Return shape is consumed by list/status/create/squash/rebase-snapshot CLIs
+ * and by the Studio's frontend MigrationsTab to render a context picker.
+ */
+import path from 'node:path';
+import { findFiles, readText, fileExists } from '../../../lib/fs.js';
+import { parseCsprojVersion } from './parse-csproj-version.js';
+
+export interface MigrationAssembly {
+  /** Absolute path to the .csproj that owns the migrations folder. */
+  csprojPath: string;
+  /** Assembly name derived from csproj filename (minus ".csproj"). */
+  assemblyName: string;
+  /** Absolute path to the directory containing the migrations + snapshot. */
+  migrationsDir: string;
+  /** Snapshot file inside migrationsDir. */
+  snapshotPath: string;
+  /** Inferred provider: "sqlite" / "postgres" / "sqlserver" / null. */
+  provider: string | null;
+  /** Version read from the csproj <Version> element (or "0.1.0" fallback). */
+  version: string;
+}
+
+export interface DbContextInfo {
+  /** Partial-class name from the snapshot (e.g. "CoreDbContext"). */
+  name: string;
+  /** One entry per migration assembly that targets this context. */
+  assemblies: MigrationAssembly[];
+}
+
+export interface DetectionResult {
+  /** Kind heuristic: "generated" app (Core+Extensions) / "studio" / "unknown". */
+  kind: 'generated' | 'studio' | 'unknown';
+  contexts: DbContextInfo[];
+  /** Absolute working directory used for detection. */
+  cwd: string;
+}
+
+const PROVIDER_HINTS: Array<[RegExp, string]> = [
+  [/\bSqlite\b/i, 'sqlite'],
+  [/\bPostgres(?:ql)?\b/i, 'postgres'],
+  [/\bNpgsql\b/i, 'postgres'],
+  [/\bSqlServer\b/i, 'sqlserver'],
+  [/\bMssql\b/i, 'sqlserver'],
+];
+
+function inferProvider(csprojPath: string, migrationsDir: string): string | null {
+  const haystack = `${csprojPath} ${migrationsDir}`;
+  for (const [re, name] of PROVIDER_HINTS) {
+    if (re.test(haystack)) return name;
+  }
+  return null;
+}
+
+async function extractContextNameFromSnapshot(snapshotPath: string): Promise<string | null> {
+  try {
+    const text = await readText(snapshotPath);
+    // Matches both:
+    //   [DbContext(typeof(CoreDbContext))]
+    //   partial class CoreDbContextModelSnapshot : ModelSnapshot
+    const attr = text.match(/DbContext\s*\(\s*typeof\s*\(\s*(\w+)\s*\)/);
+    if (attr) return attr[1];
+    const cls = text.match(/partial\s+class\s+(\w+?)ModelSnapshot\b/);
+    if (cls) return cls[1];
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function findOwningCsproj(snapshotPath: string, cwd: string): Promise<string | null> {
+  // Walk up from the snapshot file looking for a .csproj in the same directory
+  // tree. EF Core always places migrations inside the project that references
+  // `Microsoft.EntityFrameworkCore.Design`.
+  let dir = path.dirname(snapshotPath);
+  const cwdResolved = path.resolve(cwd);
+  while (path.resolve(dir).startsWith(cwdResolved)) {
+    const csprojFiles = await findFiles('*.csproj', { cwd: dir });
+    const direct = csprojFiles.filter((f) => path.dirname(f) === dir);
+    if (direct.length > 0) return direct[0];
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function classify(contexts: DbContextInfo[]): DetectionResult['kind'] {
+  const names = new Set(contexts.map((c) => c.name.toLowerCase()));
+  if (names.has('studiodbcontext')) return 'studio';
+  // SmartStack-generated apps expose CoreDbContext, ExtensionsDbContext, or
+  // both. Older / minimal scaffolds may ship only Extensions.
+  if (names.has('coredbcontext') || names.has('extensionsdbcontext')) return 'generated';
+  if (contexts.length > 0) return 'unknown';
+  return 'unknown';
+}
+
+export async function detectDbContexts(cwd: string): Promise<DetectionResult> {
+  const snapshots = await findFiles('**/Migrations/**/*ModelSnapshot.cs', { cwd });
+
+  const grouped = new Map<string, DbContextInfo>();
+
+  for (const snapshot of snapshots) {
+    const name = await extractContextNameFromSnapshot(snapshot);
+    if (!name) continue;
+
+    const csproj = await findOwningCsproj(snapshot, cwd);
+    if (!csproj) continue;
+
+    const migrationsDir = path.dirname(snapshot);
+    const assemblyName = path.basename(csproj, '.csproj');
+    const version = await parseCsprojVersion(csproj);
+    const provider = inferProvider(csproj, migrationsDir);
+
+    const entry = grouped.get(name) ?? { name, assemblies: [] };
+    // Skip duplicates (same assembly found twice by the glob)
+    if (!entry.assemblies.some((a) => a.csprojPath === csproj && a.migrationsDir === migrationsDir)) {
+      entry.assemblies.push({
+        csprojPath: csproj,
+        assemblyName,
+        migrationsDir,
+        snapshotPath: snapshot,
+        provider,
+        version,
+      });
+    }
+    grouped.set(name, entry);
+  }
+
+  const contexts = Array.from(grouped.values()).map((c) => ({
+    ...c,
+    assemblies: c.assemblies.sort((a, b) => a.assemblyName.localeCompare(b.assemblyName)),
+  }));
+
+  return {
+    kind: classify(contexts),
+    contexts: contexts.sort((a, b) => a.name.localeCompare(b.name)),
+    cwd: path.resolve(cwd),
+  };
+}
+
+/**
+ * Startup-project heuristic: EF Core design-time commands need a project that
+ * references the DbContext AND can be run (Microsoft.NET.Sdk.Web or an .exe
+ * Sdk). We pick a project whose name ends with `.Host` / `.Api` / `.Web`;
+ * failing that, the first assembly in alphabetical order.
+ */
+export async function findStartupProject(cwd: string): Promise<string | null> {
+  const all = await findFiles('**/*.csproj', { cwd });
+  const ranked = all
+    .map((f) => ({ f, base: path.basename(f, '.csproj') }))
+    .sort((a, b) => {
+      const score = (name: string) => {
+        if (/\.Host$/i.test(name)) return 0;
+        if (/\.Api$/i.test(name)) return 1;
+        if (/\.Web$/i.test(name)) return 2;
+        return 9;
+      };
+      const sa = score(a.base);
+      const sb = score(b.base);
+      if (sa !== sb) return sa - sb;
+      return a.base.localeCompare(b.base);
+    });
+  for (const { f } of ranked) {
+    try {
+      const content = await readText(f);
+      if (/<Project\s+Sdk="Microsoft\.NET\.Sdk\.Web"/i.test(content)) return f;
+      if (/<OutputType>\s*Exe\s*<\/OutputType>/i.test(content)) return f;
+    } catch {
+      continue;
+    }
+  }
+  return ranked[0]?.f ?? null;
+}
+
+export async function hasDotnetProject(cwd: string): Promise<boolean> {
+  const anyCsproj = (await findFiles('**/*.csproj', { cwd })).length > 0;
+  if (!anyCsproj) return false;
+  const slnOrSlnx =
+    (await findFiles('**/*.sln', { cwd })).length > 0 ||
+    (await findFiles('**/*.slnx', { cwd })).length > 0;
+  return slnOrSlnx || anyCsproj;
+}
+
+export async function pathExists(p: string): Promise<boolean> {
+  return fileExists(p);
+}

package/templates/skills/efcore/cli/lib/ef-runner.ts

@@ -0,0 +1,144 @@
+/**
+ * ef-runner.ts — Spawn wrapper for `dotnet ef` commands.
+ *
+ * `dotnet ef` must be on the PATH (`dotnet tool install --global dotnet-ef`).
+ * On Windows the global tools cache is at `%USERPROFILE%\.dotnet\tools`; under
+ * Git Bash `$HOME/.dotnet/tools`. Both are prepended to PATH so the wrapper
+ * works from either shell.
+ */
+import { execFile } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+
+export interface EfRunResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+function buildPathEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.dotnet', 'tools'),
+    process.env.USERPROFILE ? path.join(process.env.USERPROFILE, '.dotnet', 'tools') : null,
+  ].filter((p): p is string => Boolean(p));
+  const sep = process.platform === 'win32' ? ';' : ':';
+  const existing = env.PATH ?? env.Path ?? '';
+  const merged = [...candidates, existing].filter(Boolean).join(sep);
+  env.PATH = merged;
+  env.Path = merged;
+  return env;
+}
+
+export function runDotnet(
+  args: string[],
+  cwd: string,
+  opts: { timeoutMs?: number; extraEnv?: NodeJS.ProcessEnv } = {},
+): Promise<EfRunResult> {
+  const timeout = opts.timeoutMs ?? 180_000;
+  return new Promise((resolve) => {
+    execFile(
+      'dotnet',
+      args,
+      {
+        cwd,
+        encoding: 'utf-8',
+        timeout,
+        maxBuffer: 20 * 1024 * 1024,
+        env: { ...buildPathEnv(), ...(opts.extraEnv ?? {}) },
+      },
+      (error, stdout, stderr) => {
+        resolve({
+          stdout: (stdout || '').trim(),
+          stderr: (stderr || '').trim(),
+          exitCode: error ? ((error as NodeJS.ErrnoException).code as number | undefined ?? 1) : 0,
+        });
+      },
+    );
+  });
+}
+
+/**
+ * Fetch the list of migrations as parsed JSON. Uses `--json` which EF Core
+ * 10 supports on `migrations list`. Fallback to text parsing if `--json` is
+ * unavailable on the target SDK.
+ */
+export async function listMigrationsJson(
+  cwd: string,
+  opts: { context?: string; projectPath?: string; startupProjectPath?: string; extraEnv?: NodeJS.ProcessEnv } = {},
+): Promise<{
+  success: boolean;
+  migrations: Array<{ id: string; name: string; applied: boolean }>;
+  raw: string;
+  error?: string;
+}> {
+  const args = ['ef', 'migrations', 'list', '--json', '--no-color'];
+  if (opts.context) args.push('--context', opts.context);
+  if (opts.projectPath) args.push('--project', opts.projectPath);
+  if (opts.startupProjectPath) args.push('--startup-project', opts.startupProjectPath);
+
+  const result = await runDotnet(args, cwd, { extraEnv: opts.extraEnv });
+  if (result.exitCode !== 0) {
+    return {
+      success: false,
+      migrations: [],
+      raw: result.stdout + (result.stderr ? `\n${result.stderr}` : ''),
+      error: result.stderr || result.stdout || 'dotnet ef migrations list failed',
+    };
+  }
+
+  const parsed = extractJsonBlock(result.stdout);
+  if (!parsed) {
+    // Fallback: plain text parse (one migration per line, applied ones have no marker)
+    const lines = result.stdout
+      .split('\n')
+      .map((l) => l.trim())
+      .filter((l) => l && !l.startsWith('Build') && !l.startsWith('info:') && !l.includes('Done.'));
+    return {
+      success: true,
+      raw: result.stdout,
+      migrations: lines.map((line) => ({
+        id: line.replace(/\s+\(Pending\)$/, ''),
+        name: line.replace(/\s+\(Pending\)$/, ''),
+        applied: !/\(Pending\)$/.test(line),
+      })),
+    };
+  }
+
+  const migrations = (Array.isArray(parsed) ? parsed : []).map((m) => ({
+    id: String(m.id ?? m.name ?? ''),
+    name: String(m.name ?? m.id ?? ''),
+    applied: Boolean(m.applied),
+  }));
+
+  return { success: true, migrations, raw: result.stdout };
+}
+
+function extractJsonBlock(text: string): unknown | null {
+  // `dotnet ef --json` emits a marker line around the JSON payload on newer SDKs.
+  const lines = text.split('\n');
+  const startIdx = lines.findIndex((l) => l.trim().startsWith('['));
+  if (startIdx === -1) return null;
+  // Find matching end bracket (greedy — the JSON is always the last array).
+  for (let end = lines.length - 1; end >= startIdx; end--) {
+    const block = lines.slice(startIdx, end + 1).join('\n').trim();
+    if (!block.endsWith(']')) continue;
+    try {
+      return JSON.parse(block);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+export async function dotnetAvailable(): Promise<boolean> {
+  const res = await runDotnet(['--version'], process.cwd(), { timeoutMs: 5_000 });
+  return res.exitCode === 0;
+}
+
+export async function dotnetEfAvailable(): Promise<boolean> {
+  const res = await runDotnet(['ef', '--version'], process.cwd(), { timeoutMs: 10_000 });
+  return res.exitCode === 0;
+}

package/templates/skills/efcore/cli/lib/migration-name.ts

@@ -0,0 +1,56 @@
+/**
+ * migration-name.ts — Pure naming formatter.
+ *
+ * Convention ported from the global /efcore agents (without MCP):
+ *   {contextPrefix}_v{version_underscore}_{seq3}_{PascalCaseDescription}
+ *
+ * Examples:
+ *   core_v0_4_0_007_AddEmployeeAvatar
+ *   ext_v1_0_0_003_CreateOrders
+ *   studio_v1_0_0_005_AddBugWorkflow
+ *
+ * - `contextPrefix` is lowercased and collapsed (ExtensionsDbContext → ext,
+ *   CoreDbContext → core, StudioDbContext → studio).
+ * - Description is PascalCase with only [A-Za-z0-9] characters. Empty input
+ *   throws — the caller must validate.
+ */
+import { normalizeVersionForName } from './parse-csproj-version.js';
+
+export interface MigrationNameInput {
+  contextName: string;
+  version: string;
+  sequence: number;
+  description: string;
+}
+
+export function contextPrefix(contextName: string): string {
+  const stripped = contextName.replace(/DbContext$/i, '').replace(/Context$/i, '');
+  const lower = stripped.toLowerCase();
+  if (lower === 'extensions') return 'ext';
+  if (lower === 'extension') return 'ext';
+  return lower || 'db';
+}
+
+export function toPascalCase(input: string): string {
+  const parts = input
+    .replace(/[^A-Za-z0-9\s_-]/g, ' ')
+    .split(/[\s_-]+/)
+    .filter(Boolean);
+  if (parts.length === 0) return '';
+  return parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join('');
+}
+
+export function padSequence(n: number): string {
+  return String(Math.max(0, Math.floor(n))).padStart(3, '0');
+}
+
+export function buildMigrationName(input: MigrationNameInput): string {
+  const desc = toPascalCase(input.description);
+  if (!desc) {
+    throw new Error('description must contain at least one alphanumeric character');
+  }
+  const prefix = contextPrefix(input.contextName);
+  const vPart = normalizeVersionForName(input.version);
+  const seq = padSequence(input.sequence);
+  return `${prefix}_v${vPart}_${seq}_${desc}`;
+}

package/templates/skills/efcore/cli/lib/parse-csproj-version.ts

@@ -0,0 +1,45 @@
+/**
+ * parse-csproj-version.ts — Extract <Version> from a .csproj file.
+ *
+ * The {context}_v{version}_{seq}_{Description} naming convention requires a
+ * version tag. We prefer the csproj <Version> element; when absent we fall
+ * back to <AssemblyVersion> or default to "0.1.0".
+ *
+ * Pre-release suffixes and build metadata are stripped so "0.1.0-dev.3" and
+ * "0.1.0+sha.abc" both normalize to "0.1.0".
+ */
+import { readText } from '../../../lib/fs.js';
+
+const DEFAULT_VERSION = '0.1.0';
+
+export async function parseCsprojVersion(csprojPath: string): Promise<string> {
+  let content: string;
+  try {
+    content = await readText(csprojPath);
+  } catch {
+    return DEFAULT_VERSION;
+  }
+
+  const version = matchTag(content, 'Version')
+    ?? matchTag(content, 'AssemblyVersion')
+    ?? matchTag(content, 'FileVersion');
+
+  if (!version) return DEFAULT_VERSION;
+
+  // Strip pre-release and build metadata: 0.1.0-dev.1+sha → 0.1.0
+  const core = version.split(/[-+]/)[0].trim();
+  return /^\d+(\.\d+){0,3}$/.test(core) ? core : DEFAULT_VERSION;
+}
+
+function matchTag(content: string, tag: string): string | null {
+  const re = new RegExp(`<${tag}>([^<]+)</${tag}>`, 'i');
+  const m = content.match(re);
+  return m ? m[1].trim() : null;
+}
+
+export function normalizeVersionForName(version: string): string {
+  // Defensive: strip pre-release / build metadata even if the caller forgot
+  // to run it through parseCsprojVersion first.
+  const core = version.split(/[-+]/)[0].trim() || version;
+  return core.replace(/\./g, '_');
+}

package/templates/skills/efcore/cli/list/execute.ts

@@ -0,0 +1,83 @@
+import { detectDbContexts, findStartupProject, hasDotnetProject } from '../lib/detect-dbcontexts.js';
+import { listMigrationsJson, dotnetAvailable, dotnetEfAvailable } from '../lib/ef-runner.js';
+import type { AssemblyListing, ContextListing, ListResult, ListSpec } from './types.js';
+
+export async function execute(spec: ListSpec): Promise<ListResult> {
+  const warnings: string[] = [];
+
+  if (!(await hasDotnetProject(spec.cwd))) {
+    return {
+      success: true,
+      cwd: spec.cwd,
+      kind: 'unknown',
+      contexts: [],
+      warnings: ['No .csproj found in worktree — nothing to list.'],
+    };
+  }
+
+  if (!(await dotnetAvailable())) {
+    return {
+      success: false,
+      cwd: spec.cwd,
+      kind: 'unknown',
+      contexts: [],
+      warnings,
+      error: 'dotnet CLI is not available on PATH',
+    };
+  }
+
+  if (!(await dotnetEfAvailable())) {
+    warnings.push('dotnet-ef tool is not installed globally — run: dotnet tool install --global dotnet-ef');
+  }
+
+  const detection = await detectDbContexts(spec.cwd);
+  const startupProject = await findStartupProject(spec.cwd);
+
+  const out: ContextListing[] = [];
+
+  for (const ctx of detection.contexts) {
+    if (spec.contextName && ctx.name !== spec.contextName) continue;
+
+    const assemblies: AssemblyListing[] = [];
+    for (const asm of ctx.assemblies) {
+      if (spec.assembly && asm.assemblyName !== spec.assembly) continue;
+
+      const extraEnv = asm.provider
+        ? { STUDIO_DESIGN_PROVIDER: capitalize(asm.provider) }
+        : undefined;
+
+      const result = await listMigrationsJson(spec.cwd, {
+        context: ctx.name,
+        projectPath: asm.csprojPath,
+        startupProjectPath: startupProject ?? undefined,
+        extraEnv,
+      });
+
+      assemblies.push({
+        assemblyName: asm.assemblyName,
+        csprojPath: asm.csprojPath,
+        migrationsDir: asm.migrationsDir,
+        provider: asm.provider,
+        version: asm.version,
+        migrations: result.migrations,
+        error: result.success ? undefined : result.error,
+      });
+    }
+
+    out.push({ contextName: ctx.name, assemblies });
+  }
+
+  return {
+    success: true,
+    cwd: detection.cwd,
+    kind: detection.kind,
+    contexts: out,
+    warnings,
+  };
+}
+
+function capitalize(s: string): string {
+  if (!s) return s;
+  if (s.toLowerCase() === 'sqlserver') return 'SqlServer';
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/templates/skills/efcore/cli/list/index.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * cli:efcore-list — List EF Core migrations for a worktree.
+ *
+ * Usage:
+ *   npx tsx skills/efcore/cli/list/index.ts --spec '{"cwd":"D:/path/to/worktree"}'
+ */
+import { parseArgs } from 'node:util';
+import { existsSync, readFileSync } from 'node:fs';
+import { validate } from './validate.js';
+import { execute } from './execute.js';
+
+async function main(): Promise<void> {
+  const { values } = parseArgs({
+    options: {
+      spec: { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+    },
+  });
+
+  if (values.help || !values.spec) {
+    printHelp();
+    process.exit(values.help ? 0 : 1);
+  }
+
+  let raw: unknown;
+  try {
+    raw = existsSync(values.spec!) ? JSON.parse(readFileSync(values.spec!, 'utf-8')) : JSON.parse(values.spec!);
+  } catch (err) {
+    console.log(JSON.stringify({ success: false, error: `Invalid JSON spec: ${(err as Error).message}` }, null, 2));
+    process.exit(1);
+  }
+
+  const validation = validate(raw);
+  if (!validation.valid || !validation.data) {
+    console.log(JSON.stringify({ success: false, errors: validation.blockers, warnings: validation.warnings }, null, 2));
+    process.exit(1);
+  }
+
+  const result = await execute(validation.data);
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(result.success ? 0 : 1);
+}
+
+function printHelp(): void {
+  console.log(`
+cli:efcore-list — SmartStack Studio
+
+Lists EF Core migrations in a worktree, grouped by DbContext and migration
+assembly. Applied + pending status per migration.
+
+Usage:
+  npx tsx skills/efcore/cli/list/index.ts --spec '<json>'
+
+Spec:
+  { "cwd": "<worktree path>", "contextName"?: "<name>", "assembly"?: "<name>" }
+`);
+}
+
+void main();

package/templates/skills/efcore/cli/list/types.ts

@@ -0,0 +1,46 @@
+/**
+ * list CLI types — input spec + result.
+ *
+ * Read-only: scans a worktree and returns all EF Core migrations grouped by
+ * DbContext and migration assembly. Used by the Studio's MigrationsTab and
+ * by the list agent prompt.
+ */
+import { z } from 'zod';
+
+export const ListSpecSchema = z.object({
+  cwd: z.string().min(1, 'cwd is required'),
+  contextName: z.string().optional(),
+  assembly: z.string().optional(),
+});
+export type ListSpec = z.infer<typeof ListSpecSchema>;
+
+export interface MigrationEntry {
+  id: string;
+  name: string;
+  applied: boolean;
+}
+
+export interface AssemblyListing {
+  assemblyName: string;
+  csprojPath: string;
+  migrationsDir: string;
+  provider: string | null;
+  version: string;
+  migrations: MigrationEntry[];
+  /** When `dotnet ef migrations list --json` fails, this carries the reason. */
+  error?: string;
+}
+
+export interface ContextListing {
+  contextName: string;
+  assemblies: AssemblyListing[];
+}
+
+export interface ListResult {
+  success: boolean;
+  cwd: string;
+  kind: 'generated' | 'studio' | 'unknown';
+  contexts: ContextListing[];
+  warnings: string[];
+  error?: string;
+}

package/templates/skills/efcore/cli/list/validate.ts

@@ -0,0 +1,20 @@
+import { ListSpecSchema, type ListSpec } from './types.js';
+
+export interface ValidationResult {
+  valid: boolean;
+  data?: ListSpec;
+  blockers: string[];
+  warnings: string[];
+}
+
+export function validate(raw: unknown): ValidationResult {
+  const blockers: string[] = [];
+  const parsed = ListSpecSchema.safeParse(raw);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) {
+      blockers.push(`[${issue.path.join('.')}] ${issue.message}`);
+    }
+    return { valid: false, blockers, warnings: [] };
+  }
+  return { valid: true, data: parsed.data, blockers, warnings: [] };
+}

package/templates/skills/efcore/cli/rebase-snapshot/execute.ts

@@ -0,0 +1,21 @@
+import { execute as executeSquash } from '../squash/execute.js';
+import type { RebaseSnapshotSpec, RebaseSnapshotResult } from './types.js';
+
+/**
+ * rebase-snapshot re-uses the squash implementation. The difference is
+ * intent: squash is called before merging a feature branch, rebase-snapshot
+ * is called after a rebase that left ModelSnapshot.cs in a conflicted
+ * state. Both end up in the same place: one consolidated migration on top
+ * of the base branch's snapshot.
+ */
+export async function execute(spec: RebaseSnapshotSpec): Promise<RebaseSnapshotResult> {
+  return executeSquash({
+    cwd: spec.cwd,
+    contextName: spec.contextName,
+    description: spec.description,
+    assembly: spec.assembly,
+    baseBranch: spec.baseBranch,
+    dryRun: spec.dryRun ?? false,
+    aggressive: false,
+  });
+}