becky-cli 0.2.12

package/README.md

@@ -0,0 +1,102 @@
+# becky-cli
+
+CLI for local Postgres setup and wiring Becky–generated backends.
+
+## Install
+
+```bash
+npm install -g becky-cli
+# or without installing:
+npx becky-cli --help
+```
+
+## Quick start (after unzipping a generated project)
+
+```bash
+cd my-backend
+npx becky-cli up .
+```
+
+That will:
+
+1. Install/start Postgres if needed (Ubuntu/Debian)
+2. Create user + database
+3. Write `.env` with `DATABASE_URL`
+4. Run stack migrations (Prisma / Alembic / scripts)
+
+Then start your API as described in the project README.
+
+## Commands
+
+| Command | What it does | AI? |
+|---------|--------------|-----|
+| `becky postgres status` | Check install + service | No |
+| `becky postgres setup` | Install Postgres, create user/DB | No |
+| `becky connect [dir]` | Write `.env`, test connection | No |
+| `becky migrate [dir]` | Run migrations for the stack | No |
+| `becky up [dir]` | setup + connect + migrate | No |
+| `becky doctor [dir]` | Health checks; OpenAI diagnosis if issues | Yes* |
+| `becky config set-key` | Save OpenAI API key | — |
+| `becky config show` | Show masked config | — |
+
+\* AI only runs when checks fail **and** a key is available.
+
+## OpenAI (for `doctor`)
+
+The CLI does **not** need OpenAI for setup/connect/migrate.  
+Only `doctor` uses it when something is wrong.
+
+Set a key one of these ways:
+
+```bash
+# Option A — save locally (chmod 600 under ~/.becky/)
+becky config set-key
+
+# Option B — environment
+export OPENAI_API_KEY=sk-...
+
+# Option C — one-shot flag
+becky doctor . --api-key sk-...
+```
+
+Optional model:
+
+```bash
+becky config set-model gpt-4o-mini
+becky doctor . --model gpt-4o
+```
+
+Checks only (no AI):
+
+```bash
+becky doctor . --skip-ai
+```
+
+## Examples
+
+```bash
+becky postgres status
+becky postgres setup --spec ./project-spec.json -y
+# creates user + database both named after the project (e.g. bicycle_marketplace)
+becky connect . --force
+becky migrate .
+becky up . -y
+becky doctor .
+```
+
+Credentials from `postgres setup` / `connect` are stored in `~/.becky/credentials.json` so you are not re-prompted every time.
+
+## Requirements
+
+- Node.js 18+
+- Linux (Ubuntu/Debian) for `postgres setup` — macOS/Windows later
+- `sudo` for package install and postgres admin commands
+- OpenAI key only for AI diagnosis in `doctor`
+
+## Generated projects
+
+Every Becky ZIP includes `project-spec.json`. Point the CLI at that folder:
+
+```bash
+npx becky-cli up ./path/to/unzipped-project
+```

package/dist/ai/openai.d.ts

@@ -0,0 +1,17 @@
+export type DoctorAiInput = {
+    projectName: string;
+    stack: string;
+    checks: {
+        id: string;
+        ok: boolean;
+        detail: string;
+    }[];
+    apiKey?: string;
+    model?: string;
+};
+export type DoctorAiAdvice = {
+    summary: string;
+    suggestedCommands: string[];
+    notes: string[];
+};
+export declare function askDoctorAdvice(input: DoctorAiInput): Promise<DoctorAiAdvice>;

package/dist/ai/openai.js

@@ -0,0 +1,67 @@
+import { resolveOpenAiKey, loadConfig } from "../config/store.js";
+export async function askDoctorAdvice(input) {
+    const apiKey = resolveOpenAiKey(input.apiKey);
+    if (!apiKey) {
+        throw new Error("OpenAI API key required for AI diagnosis. Set OPENAI_API_KEY, run `becky config set-key`, or pass --api-key.");
+    }
+    const model = input.model || loadConfig().defaultModel || "gpt-4o-mini";
+    const failed = input.checks.filter((c) => !c.ok);
+    const passed = input.checks.filter((c) => c.ok);
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model,
+            response_format: { type: "json_object" },
+            temperature: 0.2,
+            max_tokens: 1200,
+            messages: [
+                {
+                    role: "system",
+                    content: `You are Becky doctor — a local backend/Postgres troubleshooter.
+Return ONLY JSON:
+{
+  "summary": "1-3 sentences",
+  "suggestedCommands": ["shell commands the user can run"],
+  "notes": ["short tips"]
+}
+Prefer becky CLI commands (postgres setup, connect, migrate, up) and standard stack tools.
+Do not invent credentials. Keep commands safe for local Ubuntu/Debian.`,
+                },
+                {
+                    role: "user",
+                    content: `Project: ${input.projectName}
+Stack: ${input.stack}
+
+Passed checks:
+${passed.map((c) => `- ${c.id}: ${c.detail}`).join("\n") || "(none)"}
+
+Failed checks:
+${failed.map((c) => `- ${c.id}: ${c.detail}`).join("\n") || "(none)"}
+
+Suggest concrete next steps.`,
+                },
+            ],
+        }),
+    });
+    const data = (await res.json());
+    if (!res.ok) {
+        throw new Error(data.error?.message || `OpenAI request failed (${res.status})`);
+    }
+    const content = data.choices?.[0]?.message?.content;
+    if (!content)
+        throw new Error("Empty response from OpenAI");
+    const parsed = JSON.parse(content);
+    return {
+        summary: typeof parsed.summary === "string" ? parsed.summary : "AI diagnosis complete.",
+        suggestedCommands: Array.isArray(parsed.suggestedCommands)
+            ? parsed.suggestedCommands.filter((c) => typeof c === "string")
+            : [],
+        notes: Array.isArray(parsed.notes)
+            ? parsed.notes.filter((n) => typeof n === "string")
+            : [],
+    };
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,3 @@
+export declare function runConfigSetKey(apiKey?: string): Promise<void>;
+export declare function runConfigShow(): void;
+export declare function runConfigSetModel(model: string): void;

package/dist/commands/config.js

@@ -0,0 +1,30 @@
+import { loadConfig, resolveOpenAiKey, saveConfig, getConfigDir } from "../config/store.js";
+import { promptHidden } from "../util/prompt.js";
+import { detail, info, success, warn } from "../util/log.js";
+export async function runConfigSetKey(apiKey) {
+    let key = apiKey?.trim();
+    if (!key) {
+        key = await promptHidden("OpenAI API key (sk-...)");
+    }
+    if (!key) {
+        throw new Error("API key is required");
+    }
+    saveConfig({ openaiApiKey: key });
+    success(`Saved OpenAI key to ${getConfigDir()}/config.json`);
+    detail("Used by: becky doctor (and future AI commands)");
+    info("You can also use OPENAI_API_KEY in the environment instead.");
+}
+export function runConfigShow() {
+    const config = loadConfig();
+    const key = resolveOpenAiKey();
+    console.log(`Config dir: ${getConfigDir()}`);
+    console.log(`OpenAI key: ${key ? `${key.slice(0, 7)}…${key.slice(-4)}` : "(not set)"}`);
+    console.log(`Default model: ${config.defaultModel || "gpt-4o-mini"}`);
+    if (!key) {
+        warn("Set a key with: becky config set-key");
+    }
+}
+export function runConfigSetModel(model) {
+    saveConfig({ defaultModel: model.trim() });
+    success(`Default model set to ${model.trim()}`);
+}

package/dist/commands/connect.d.ts

@@ -0,0 +1,11 @@
+export type ConnectOptions = {
+    dir: string;
+    user?: string;
+    password?: string;
+    database?: string;
+    host?: string;
+    port?: number;
+    force?: boolean;
+    skipTest?: boolean;
+};
+export declare function runConnect(options: ConnectOptions): Promise<void>;

package/dist/commands/connect.js

@@ -0,0 +1,36 @@
+import { saveCredentials } from "../config/store.js";
+import { resolveConnection, testDatabaseConnection, writeEnvFile } from "../project/env.js";
+import { loadProject } from "../project/load.js";
+import { detail, info, step, success } from "../util/log.js";
+export async function runConnect(options) {
+    const project = loadProject(options.dir);
+    step(`Becky — connect (${project.spec.projectName})`);
+    detail(`Project: ${project.root}`);
+    detail(`Stack:   ${project.spec.stack}`);
+    const connection = await resolveConnection(project, {
+        user: options.user,
+        password: options.password,
+        database: options.database,
+        host: options.host,
+        port: options.port,
+    });
+    writeEnvFile(project, connection, options.force);
+    saveCredentials({
+        host: connection.host,
+        port: connection.port,
+        user: connection.user,
+        password: connection.password,
+        database: connection.database,
+        databaseUrl: connection.databaseUrl,
+    });
+    info("Saved credentials to ~/.becky/credentials.json");
+    if (!options.skipTest) {
+        await testDatabaseConnection(connection);
+    }
+    step("Done");
+    success("Backend is wired to Postgres via .env");
+    console.log("");
+    console.log(`DATABASE_URL=${connection.databaseUrl}`);
+    console.log("");
+    info("Next: becky migrate .   (or becky up .)");
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,10 @@
+import { type LoadedProject } from "../project/load.js";
+export type DoctorOptions = {
+    dir: string;
+    apiKey?: string;
+    model?: string;
+    noAi?: boolean;
+};
+export declare function runDoctor(options: DoctorOptions): Promise<void>;
+/** Read DATABASE_URL from stack or project .env (Prisma uses stackRoot/.env). */
+export declare function peekEnvDatabaseUrl(project: LoadedProject): string | null;

package/dist/commands/doctor.js

@@ -0,0 +1,166 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { askDoctorAdvice } from "../ai/openai.js";
+import { resolveOpenAiKey } from "../config/store.js";
+import { getPostgresStatus, databaseExists } from "../postgres/admin.js";
+import { resolveConnection, testDatabaseConnection, envFilePaths } from "../project/env.js";
+import { loadProject } from "../project/load.js";
+import { run } from "../util/exec.js";
+import { detail, error, info, step, success, warn } from "../util/log.js";
+async function checkHealthEndpoint(projectRoot, stack) {
+    const ports = stack === "fastapi-postgres" ? [8000, 3000] : [3000, 8000];
+    for (const port of ports) {
+        const result = await run("curl", ["-sf", `http://127.0.0.1:${port}/health`]);
+        if (result.code === 0) {
+            return { id: "api-health", ok: true, detail: `GET :${port}/health responded` };
+        }
+    }
+    return {
+        id: "api-health",
+        ok: false,
+        detail: "API /health not reachable (start the server from the project README)",
+    };
+}
+export async function runDoctor(options) {
+    const project = loadProject(options.dir);
+    const checks = [];
+    step(`Becky — doctor (${project.spec.projectName})`);
+    detail(`Stack: ${project.spec.stack}`);
+    const pg = await getPostgresStatus();
+    checks.push({
+        id: "postgres-installed",
+        ok: pg.installed,
+        detail: pg.installed ? pg.version || "psql found" : "PostgreSQL / psql not found",
+    });
+    checks.push({
+        id: "postgres-service",
+        ok: pg.serviceActive,
+        detail: pg.serviceActive ? "postgresql service active" : "postgresql service not running",
+    });
+    const envPaths = envFilePaths(project);
+    const hasEnv = envPaths.some((p) => existsSync(p));
+    checks.push({
+        id: "env-file",
+        ok: hasEnv,
+        detail: hasEnv
+            ? `.env present (${envPaths.filter((p) => existsSync(p)).join(", ")})`
+            : `.env missing — run becky connect .`,
+    });
+    let dbOk = false;
+    try {
+        if (pg.installed) {
+            const connection = await resolveConnection(project, { promptIfMissing: false });
+            const exists = await databaseExists(connection.database);
+            checks.push({
+                id: "database-exists",
+                ok: exists,
+                detail: exists
+                    ? `Database "${connection.database}" exists`
+                    : `Database "${connection.database}" missing — run becky postgres setup`,
+            });
+            if (hasEnv) {
+                try {
+                    await testDatabaseConnection(connection);
+                    dbOk = true;
+                    checks.push({ id: "database-connect", ok: true, detail: "DATABASE_URL connection OK" });
+                }
+                catch (err) {
+                    checks.push({
+                        id: "database-connect",
+                        ok: false,
+                        detail: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        checks.push({
+            id: "credentials",
+            ok: false,
+            detail: err instanceof Error ? err.message : String(err),
+        });
+    }
+    const health = await checkHealthEndpoint(project.root, project.spec.stack);
+    checks.push(health);
+    // Optional: look for migration stubs still TODO
+    if (project.spec.outputs?.migrations !== false) {
+        const migrateScript = join(project.root, "scripts", "migrate.sh");
+        checks.push({
+            id: "migrate-script",
+            ok: existsSync(migrateScript),
+            detail: existsSync(migrateScript)
+                ? "scripts/migrate.sh present"
+                : "No scripts/migrate.sh (migrations may be stubs)",
+        });
+    }
+    console.log("");
+    for (const check of checks) {
+        if (check.ok)
+            success(`${check.id}: ${check.detail}`);
+        else
+            error(`${check.id}: ${check.detail}`);
+    }
+    const failed = checks.filter((c) => !c.ok);
+    if (failed.length === 0) {
+        step("Healthy");
+        success("All checks passed");
+        if (dbOk)
+            detail("Database is connected and reachable");
+        return;
+    }
+    step(`${failed.length} issue(s) found`);
+    if (options.noAi) {
+        warn("Skipping AI diagnosis (--skip-ai)");
+        info("Try: becky up .");
+        return;
+    }
+    if (!resolveOpenAiKey(options.apiKey)) {
+        warn("No OpenAI API key — skipping AI diagnosis");
+        info("Set a key with:  becky config set-key");
+        info("Or:              export OPENAI_API_KEY=sk-...");
+        info("Then re-run:     becky doctor .");
+        info("Quick fix:       becky up .");
+        return;
+    }
+    info("Asking OpenAI for fix suggestions…");
+    try {
+        const advice = await askDoctorAdvice({
+            projectName: project.spec.projectName,
+            stack: project.spec.stack,
+            checks,
+            apiKey: options.apiKey,
+            model: options.model,
+        });
+        console.log("");
+        console.log(advice.summary);
+        if (advice.suggestedCommands.length) {
+            console.log("\nSuggested commands:");
+            for (const cmd of advice.suggestedCommands) {
+                console.log(`  ${cmd}`);
+            }
+        }
+        if (advice.notes.length) {
+            console.log("\nNotes:");
+            for (const note of advice.notes) {
+                console.log(`  - ${note}`);
+            }
+        }
+    }
+    catch (err) {
+        error(err instanceof Error ? err.message : String(err));
+        info("Fallback: becky up .");
+    }
+}
+/** Read DATABASE_URL from stack or project .env (Prisma uses stackRoot/.env). */
+export function peekEnvDatabaseUrl(project) {
+    for (const envPath of envFilePaths(project)) {
+        if (!existsSync(envPath))
+            continue;
+        const match = readFileSync(envPath, "utf8").match(/^DATABASE_URL=(.+)$/m);
+        const url = match?.[1]?.trim();
+        if (url)
+            return url;
+    }
+    return null;
+}

package/dist/commands/migrate.d.ts

@@ -0,0 +1,9 @@
+export type MigrateOptions = {
+    dir: string;
+    user?: string;
+    password?: string;
+    database?: string;
+    host?: string;
+    port?: number;
+};
+export declare function runMigrate(options: MigrateOptions): Promise<void>;

package/dist/commands/migrate.js

@@ -0,0 +1,208 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadCredentials } from "../config/store.js";
+import { resolveConnection } from "../project/env.js";
+import { ensureAlembicScaffold } from "../project/alembicScaffold.js";
+import { FASTAPI_REQUIREMENTS, isLegacyFastapiRequirements } from "../project/fastapiPins.js";
+import { loadProject } from "../project/load.js";
+import { run, runOrThrow } from "../util/exec.js";
+import { detail, info, step, success, warn } from "../util/log.js";
+function combinedOutput(result) {
+    return [result.stderr, result.stdout].filter(Boolean).join("\n");
+}
+function isPrismaBinaryTargetError(text) {
+    return /Unknown binaryTarget|debian-openssl-3\.\d+\.x|no custom engine files/i.test(text);
+}
+function pythonBin(project) {
+    const venvPython = join(project.stackRoot, ".venv", "bin", "python");
+    return existsSync(venvPython) ? venvPython : "python3";
+}
+async function ensurePythonDepsInstalled(project) {
+    const requirementsPath = join(project.stackRoot, "requirements.txt");
+    if (!existsSync(requirementsPath)) {
+        writeFileSync(requirementsPath, `${FASTAPI_REQUIREMENTS}\n`, "utf8");
+        info(`Created ${requirementsPath}`);
+    }
+    else {
+        const current = readFileSync(requirementsPath, "utf8");
+        if (isLegacyFastapiRequirements(current)) {
+            writeFileSync(requirementsPath, `${FASTAPI_REQUIREMENTS}\n`, "utf8");
+            warn("Replaced legacy Python pins in requirements.txt with compatible versions");
+        }
+    }
+    const venvDir = join(project.stackRoot, ".venv");
+    if (!existsSync(venvDir)) {
+        info("Creating Python venv in backend/");
+        const venvResult = await run("python3", ["-m", "venv", ".venv"], { cwd: project.stackRoot });
+        if (venvResult.code !== 0) {
+            const out = combinedOutput(venvResult);
+            if (/ensurepip|python3-venv/i.test(out)) {
+                throw new Error(`venv creation failed — install Python venv support:\n  sudo apt install python3-venv python3-pip\n${out}`);
+            }
+            throw new Error(`venv creation failed:\n${out}`);
+        }
+    }
+    const pip = join(project.stackRoot, ".venv", "bin", "pip");
+    const pipCmd = existsSync(pip) ? pip : "pip3";
+    info("Installing Python dependencies (pip)");
+    await runOrThrow(pipCmd, ["install", "--upgrade", "pip"], { cwd: project.stackRoot }, "pip upgrade failed");
+    await runOrThrow(pipCmd, ["install", "-r", "requirements.txt"], { cwd: project.stackRoot }, "pip install failed");
+    writeFileSync(join(project.stackRoot, ".venv", ".becky-deps"), new Date().toISOString(), "utf8");
+}
+async function ensureDepsInstalled(project) {
+    if (project.spec.stack === "fastapi-postgres") {
+        await ensurePythonDepsInstalled(project);
+        return;
+    }
+    const packageJson = join(project.stackRoot, "package.json");
+    const nodeModules = join(project.stackRoot, "node_modules");
+    if (!existsSync(packageJson)) {
+        warn(`No package.json at ${project.stackRoot} — skipping npm install`);
+        return;
+    }
+    if (existsSync(nodeModules)) {
+        detail("Dependencies already installed");
+        return;
+    }
+    info(`Installing npm dependencies in ${project.stackRoot}`);
+    await runOrThrow("npm", ["install"], { cwd: project.stackRoot }, "npm install failed");
+}
+/** Ubuntu/Debian OpenSSL 3.5+ often needs an explicit 3.0.x engine target on Prisma 6. */
+function patchPrismaBinaryTargets(project) {
+    const schemaPath = join(project.stackRoot, "prisma", "schema.prisma");
+    if (!existsSync(schemaPath))
+        return false;
+    let schema = readFileSync(schemaPath, "utf8");
+    if (schema.includes("binaryTargets"))
+        return false;
+    const patched = schema.replace(/generator\s+client\s*\{([^}]*)\}/m, (block, inner) => {
+        if (String(inner).includes("binaryTargets"))
+            return block;
+        return `generator client {${inner.trimEnd()}\n  binaryTargets = ["native", "debian-openssl-3.0.x"]\n}`;
+    });
+    if (patched === schema)
+        return false;
+    writeFileSync(schemaPath, patched, "utf8");
+    info('Patched prisma/schema.prisma with binaryTargets ["native", "debian-openssl-3.0.x"]');
+    return true;
+}
+async function upgradePrisma(project) {
+    info("Upgrading Prisma to latest 6.x (OpenSSL 3.5 compatibility)");
+    await runOrThrow("npm", ["install", "prisma@^6.19.0", "@prisma/client@^6.19.0"], { cwd: project.stackRoot }, "Failed to upgrade Prisma");
+}
+async function prismaDbPush(project, env) {
+    return run("npx", ["prisma", "db", "push", "--accept-data-loss"], {
+        cwd: project.stackRoot,
+        env,
+    });
+}
+async function migrateExpress(project, databaseUrl) {
+    await ensureDepsInstalled(project);
+    const env = { ...process.env, DATABASE_URL: databaseUrl };
+    // Prefer db push for scaffold stubs (empty/TODO migrations often break migrate deploy)
+    info("Running Prisma db push");
+    let push = await prismaDbPush(project, env);
+    if (push.code === 0) {
+        success("Prisma schema pushed to database");
+        return;
+    }
+    let output = combinedOutput(push);
+    detail(output);
+    if (isPrismaBinaryTargetError(output)) {
+        warn("Prisma OpenSSL/binary target mismatch — applying workaround");
+        patchPrismaBinaryTargets(project);
+        await upgradePrisma(project);
+        info("Regenerating Prisma client");
+        await run("npx", ["prisma", "generate"], { cwd: project.stackRoot, env });
+        info("Retrying Prisma db push");
+        push = await prismaDbPush(project, env);
+        if (push.code === 0) {
+            success("Prisma schema pushed to database");
+            return;
+        }
+        output = combinedOutput(push);
+    }
+    // Last resort: migrate deploy
+    warn("db push failed — trying prisma migrate deploy");
+    detail(output);
+    const deploy = await run("npx", ["prisma", "migrate", "deploy"], {
+        cwd: project.stackRoot,
+        env,
+    });
+    if (deploy.code === 0) {
+        success("Prisma migrations applied");
+        return;
+    }
+    throw new Error(`Prisma migrate failed:\n${combinedOutput(deploy)}\n\nManual fix:\n  cd ${project.stackRoot}\n  npm install prisma@latest @prisma/client@latest\n  npx prisma db push`);
+}
+async function migrateFastapi(project, databaseUrl) {
+    await ensurePythonDepsInstalled(project);
+    ensureAlembicScaffold(project);
+    const env = { ...process.env, DATABASE_URL: databaseUrl };
+    const py = pythonBin(project);
+    info("Running alembic upgrade head");
+    const result = await run(py, ["-m", "alembic", "upgrade", "head"], {
+        cwd: project.stackRoot,
+        env,
+    });
+    if (result.code === 0) {
+        success("Alembic migrations applied");
+        return;
+    }
+    const output = combinedOutput(result);
+    throw new Error(`Alembic migrate failed:\n${output}\n\nManual fix:\n  cd ${project.stackRoot}\n  source .venv/bin/activate\n  export DATABASE_URL='...'\n  python -m alembic upgrade head`);
+}
+async function migrateNest(project, databaseUrl) {
+    await ensureDepsInstalled(project);
+    const env = { ...process.env, DATABASE_URL: databaseUrl };
+    const script = join(project.root, "scripts", "migrate.sh");
+    const packageJson = join(project.stackRoot, "package.json");
+    if (existsSync(packageJson)) {
+        info("Trying npm run migration:run (if defined)");
+        const result = await run("npm", ["run", "migration:run", "--if-present"], {
+            cwd: project.stackRoot,
+            env,
+        });
+        if (result.code === 0 && !result.stdout.includes("Missing script")) {
+            success("Nest migrations applied");
+            return;
+        }
+    }
+    if (existsSync(script)) {
+        info("Running scripts/migrate.sh");
+        await runOrThrow("bash", [script], { cwd: project.root, env }, "migrate.sh failed");
+        success("Migration script finished");
+        return;
+    }
+    warn("No Nest migration command found — scaffold may still be stubs");
+}
+export async function runMigrate(options) {
+    const project = loadProject(options.dir);
+    const connection = await resolveConnection(project, {
+        user: options.user,
+        password: options.password,
+        database: options.database,
+        host: options.host,
+        port: options.port,
+        promptIfMissing: !loadCredentials(),
+    });
+    step(`Becky — migrate (${project.spec.projectName})`);
+    detail(`Stack: ${project.spec.stack}`);
+    detail(`Root:  ${project.stackRoot}`);
+    if (!project.spec.outputs?.migrations) {
+        warn("This project was generated without migrations output enabled");
+    }
+    switch (project.spec.stack) {
+        case "express-postgres":
+            await migrateExpress(project, connection.databaseUrl);
+            break;
+        case "fastapi-postgres":
+            await migrateFastapi(project, connection.databaseUrl);
+            break;
+        case "nest-postgres":
+            await migrateNest(project, connection.databaseUrl);
+            break;
+    }
+    step("Done");
+    success("Migration step finished");
+}

package/dist/commands/postgres-setup.d.ts

@@ -0,0 +1,12 @@
+export type PostgresSetupOptions = {
+    /** When omitted, derived from --spec project name or database name */
+    user?: string;
+    password?: string;
+    database?: string;
+    host: string;
+    port: number;
+    yes: boolean;
+    specPath?: string;
+};
+export declare function runPostgresSetup(options: PostgresSetupOptions): Promise<void>;
+export declare function printUnsupportedPlatform(): void;