@solcreek/cli 0.4.13 → 0.4.15

package/dist/commands/deployments.js

@@ -6,10 +6,28 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseConfig } from "@solcreek/sdk";
 import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS } from "../utils/output.js";
-export const deploymentsCommand = defineCommand({
+function resolveSlug(argSlug, jsonMode) {
+    if (argSlug)
+        return argSlug;
+    const configPath = join(process.cwd(), "creek.toml");
+    if (!existsSync(configPath)) {
+        if (jsonMode) {
+            jsonOutput({
+                ok: false,
+                error: "no_project",
+                message: "No creek.toml found. Use --project <slug> or run from a project directory.",
+            }, 1, NO_PROJECT_BREADCRUMBS);
+        }
+        consola.error("No creek.toml found. Use --project <slug> or run from a project directory.");
+        process.exit(1);
+    }
+    return parseConfig(readFileSync(configPath, "utf-8")).project.name;
+}
+// --- List (default behaviour) ---
+const deploymentsList = defineCommand({
     meta: {
-        name: "deployments",
-        description: "List recent deployments for the current project",
+        name: "list",
+        description: "List recent deployments",
     },
     args: {
         project: {
@@ -28,18 +46,7 @@ export const deploymentsCommand = defineCommand({
             consola.error("Not authenticated. Run `creek login` first.");
             process.exit(1);
         }
-        // Resolve project slug
-        let slug = args.project;
-        if (!slug) {
-            const configPath = join(process.cwd(), "creek.toml");
-            if (!existsSync(configPath)) {
-                if (jsonMode)
-                    jsonOutput({ ok: false, error: "no_project", message: "No creek.toml found. Use --project <slug> or run from a project directory." }, 1, NO_PROJECT_BREADCRUMBS);
-                consola.error("No creek.toml found. Use --project <slug> or run from a project directory.");
-                process.exit(1);
-            }
-            slug = parseConfig(readFileSync(configPath, "utf-8")).project.name;
-        }
+        const slug = resolveSlug(args.project, jsonMode);
         const client = new CreekClient(getApiUrl(), token);
         let deployments;
         try {
@@ -74,6 +81,194 @@ export const deploymentsCommand = defineCommand({
         }
     },
 });
+// --- Logs subcommand ---
+const deploymentsLogs = defineCommand({
+    meta: {
+        name: "logs",
+        description: "Read the build log for a deployment (production + branch + preview). Use --project to target a different project; --raw to print ndjson for piping. Designed so AI coding agents can diagnose failed deploys without a human relay.",
+    },
+    args: {
+        id: {
+            type: "positional",
+            description: "Deployment id (8-char short id or full uuid)",
+            required: true,
+        },
+        project: {
+            type: "string",
+            description: "Project slug (default: from creek.toml)",
+            required: false,
+        },
+        raw: {
+            type: "boolean",
+            description: "Print raw ndjson lines instead of step-grouped output",
+            default: false,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const token = getToken();
+        if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_authenticated" }, 1, AUTH_BREADCRUMBS);
+            consola.error("Not authenticated. Run `creek login` first.");
+            process.exit(1);
+        }
+        const slug = resolveSlug(args.project, jsonMode);
+        const client = new CreekClient(getApiUrl(), token);
+        // If the user passed a short id, look up the full uuid. GET endpoint
+        // requires the full id.
+        let fullId = args.id;
+        if (fullId.length < 36) {
+            try {
+                const list = await client.listDeployments(slug);
+                const match = list.find((d) => d.id.startsWith(fullId));
+                if (!match) {
+                    if (jsonMode)
+                        jsonOutput({ ok: false, error: "not_found", message: `No deployment matches id prefix '${fullId}'` }, 1);
+                    consola.error(`No deployment matches id prefix '${fullId}'`);
+                    process.exit(1);
+                }
+                fullId = match.id;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : "Failed to resolve deployment id";
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+                consola.error(msg);
+                process.exit(1);
+            }
+        }
+        let log;
+        try {
+            log = await client.getBuildLog(slug, fullId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to read build log";
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+            consola.error(msg);
+            process.exit(1);
+        }
+        if (jsonMode) {
+            jsonOutput({ ok: true, deploymentId: fullId, ...log }, 0);
+        }
+        if (!log.metadata) {
+            consola.info(log.message ?? "No build log available for this deployment.");
+            return;
+        }
+        if (args.raw) {
+            for (const e of log.entries)
+                consola.log(JSON.stringify(e));
+            return;
+        }
+        // Grouped printout: step ▸ lines. Headers carry status + duration + CK-code.
+        const grouped = groupByStep(log.entries);
+        const headerLabels = {
+            clone: "Clone",
+            detect: "Detect",
+            install: "Install",
+            build: "Build",
+            bundle: "Bundle",
+            upload: "Upload",
+            provision: "Provision",
+            activate: "Activate",
+            cleanup: "Cleanup",
+        };
+        const order = [
+            "clone",
+            "detect",
+            "install",
+            "build",
+            "bundle",
+            "upload",
+            "provision",
+            "activate",
+            "cleanup",
+        ];
+        const meta = log.metadata;
+        const statusColour = meta.status === "success" ? "\x1b[32m" :
+            meta.status === "failed" ? "\x1b[31m" :
+                "\x1b[33m";
+        consola.log(`\n  deployment ${fullId.slice(0, 8)}  ${statusColour}${meta.status}\x1b[0m`);
+        if (meta.errorCode)
+            consola.log(`  error code: ${meta.errorCode}`);
+        if (meta.errorStep)
+            consola.log(`  failed at: ${meta.errorStep}`);
+        consola.log("");
+        for (const step of order) {
+            const lines = grouped.get(step);
+            if (!lines)
+                continue;
+            const header = headerLabels[step] ?? step;
+            const duration = stepDuration(lines);
+            const failed = meta.status === "failed" && meta.errorStep === step;
+            const icon = failed ? "\x1b[31m✗\x1b[0m" : "\x1b[32m✓\x1b[0m";
+            const label = failed ? `\x1b[31m${header}\x1b[0m` : header;
+            consola.log(`  ${icon}  ${label}${duration ? ` (${duration})` : ""}`);
+            for (const l of lines) {
+                const lineColour = l.level === "error" || l.level === "fatal" ? "\x1b[31m" :
+                    l.level === "warn" ? "\x1b[33m" :
+                        "\x1b[90m";
+                consola.log(`       ${lineColour}${l.msg}\x1b[0m`);
+            }
+        }
+        if (meta.truncated) {
+            consola.warn("  (log was truncated at 5MB / 200k lines)");
+        }
+    },
+});
+function groupByStep(entries) {
+    const map = new Map();
+    for (const e of entries) {
+        let bucket = map.get(e.step);
+        if (!bucket) {
+            bucket = [];
+            map.set(e.step, bucket);
+        }
+        bucket.push(e);
+    }
+    return map;
+}
+function stepDuration(lines) {
+    if (lines.length < 2)
+        return null;
+    const sorted = [...lines].sort((a, b) => a.ts - b.ts);
+    const ms = sorted[sorted.length - 1].ts - sorted[0].ts;
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60_000)}m ${Math.floor((ms % 60_000) / 1000)}s`;
+}
+// --- Public export ---
+export const deploymentsCommand = defineCommand({
+    meta: {
+        name: "deployments",
+        description: "List deployments and read build logs",
+    },
+    args: {
+        project: {
+            type: "string",
+            description: "Project slug (default: from creek.toml)",
+            required: false,
+        },
+        ...globalArgs,
+    },
+    subCommands: {
+        list: deploymentsList,
+        logs: deploymentsLogs,
+    },
+    // Default behaviour (no subcommand) = list. Citty resolves
+    // subcommands first, so this only fires when the user types
+    // `creek deployments` with no trailing verb.
+    async run(ctx) {
+        const run = deploymentsList.run;
+        if (!run)
+            return;
+        return run(ctx);
+    },
+});
 function timeAgo(dateStr) {
     const diff = Date.now() - new Date(dateStr).getTime();
     const mins = Math.floor(diff / 60_000);

package/dist/commands/doctor.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `creek doctor` — pre-deploy sanity check.
+ *
+ * Runs the SDK rule engine against the current project, reports
+ * findings. Exits 0 if ok, 1 if any error-severity finding fires.
+ *
+ * This is the one command designed for LLM agents to invoke before
+ * `creek deploy`. With `--json` the output is ndjson-adjacent (pretty
+ * JSON, but parseable), letting an agent look up fixes by stable
+ * CK-* codes and apply them without re-reading the source.
+ */
+export declare const doctorCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    path: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+    last: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    project: {
+        type: "string";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.js

@@ -0,0 +1,344 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { runDoctor, resolveConfig, ConfigNotFoundError, } from "@solcreek/sdk";
+import { CreekClient } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, } from "../utils/output.js";
+/**
+ * `creek doctor` — pre-deploy sanity check.
+ *
+ * Runs the SDK rule engine against the current project, reports
+ * findings. Exits 0 if ok, 1 if any error-severity finding fires.
+ *
+ * This is the one command designed for LLM agents to invoke before
+ * `creek deploy`. With `--json` the output is ndjson-adjacent (pretty
+ * JSON, but parseable), letting an agent look up fixes by stable
+ * CK-* codes and apply them without re-reading the source.
+ */
+export const doctorCommand = defineCommand({
+    meta: {
+        name: "doctor",
+        description: "Analyze the project for pre-deploy issues — missing build output, deprecated config keys, Workers-incompatible deps, portability leaks.",
+    },
+    args: {
+        path: {
+            type: "positional",
+            description: "Project directory to analyze. Defaults to cwd.",
+            required: false,
+        },
+        last: {
+            type: "boolean",
+            description: "Diagnose the most recent FAILED deployment instead of running pre-deploy checks. Fetches the build log and matches errorCode against the CK-* fix table.",
+            default: false,
+        },
+        project: {
+            type: "string",
+            description: "Project slug for --last (default: read from creek.toml in cwd)",
+            required: false,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        if (args.last) {
+            await runLastFailureDiagnosis({
+                project: args.project,
+                cwd: resolve(args.path ?? process.cwd()),
+                jsonMode,
+            });
+            return;
+        }
+        const cwd = resolve(args.path ?? process.cwd());
+        const ctx = buildContext(cwd);
+        const report = runDoctor(ctx);
+        if (jsonMode) {
+            jsonOutput({
+                ok: report.ok,
+                cwd,
+                archetype: report.archetype,
+                summary: report.summary,
+                findings: report.findings,
+            }, report.ok ? 0 : 1);
+            return;
+        }
+        printHuman(cwd, report);
+        if (!report.ok)
+            process.exit(1);
+    },
+});
+function buildContext(cwd) {
+    const fileExists = (relPath) => existsSync(join(cwd, relPath));
+    const creekTomlPath = join(cwd, "creek.toml");
+    const creekTomlRaw = existsSync(creekTomlPath)
+        ? safeRead(creekTomlPath)
+        : null;
+    const pkgPath = join(cwd, "package.json");
+    const packageJson = existsSync(pkgPath)
+        ? safeParseJson(pkgPath)
+        : null;
+    const resolved = resolveConfigSafely(cwd);
+    const allDeps = {
+        ...(packageJson?.dependencies ?? {}),
+        ...(packageJson?.devDependencies ?? {}),
+    };
+    return { cwd, resolved, packageJson, creekTomlRaw, fileExists, allDeps };
+}
+function resolveConfigSafely(cwd) {
+    try {
+        return resolveConfig(cwd);
+    }
+    catch (err) {
+        if (err instanceof ConfigNotFoundError)
+            return null;
+        // Other errors (parse failures) bubble as null — the rules will
+        // still pick up partial info from creekTomlRaw + packageJson.
+        return null;
+    }
+}
+function safeRead(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function safeParseJson(path) {
+    const raw = safeRead(path);
+    if (raw === null)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Human output ───────────────────────────────────────────────────────
+const COLOR = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+};
+function tty() {
+    return process.stdout.isTTY ?? false;
+}
+function c(s, color) {
+    return tty() ? `${COLOR[color]}${s}${COLOR.reset}` : s;
+}
+function printHuman(cwd, report) {
+    consola.log("");
+    consola.log(`  ${c("⬡ creek doctor", "bold")}  ${c(cwd, "dim")}`);
+    consola.log(`  ${c("archetype:", "dim")} ${report.archetype ?? "unknown"}`);
+    consola.log("");
+    if (report.findings.length === 0) {
+        consola.log(`  ${c("✓", "green")} No issues detected. Deploy is good to go.`);
+        consola.log("");
+        return;
+    }
+    const order = ["error", "warn", "info"];
+    const grouped = groupBy(report.findings, (f) => f.severity);
+    for (const sev of order) {
+        const bucket = grouped.get(sev) ?? [];
+        for (const f of bucket) {
+            printFinding(f);
+        }
+    }
+    const parts = [];
+    if (report.summary.error)
+        parts.push(c(`${report.summary.error} error${s(report.summary.error)}`, "red"));
+    if (report.summary.warn)
+        parts.push(c(`${report.summary.warn} warning${s(report.summary.warn)}`, "yellow"));
+    if (report.summary.info)
+        parts.push(c(`${report.summary.info} info`, "cyan"));
+    consola.log(`  Summary: ${parts.join(", ")}`);
+    consola.log("");
+}
+function printFinding(f) {
+    const icon = f.severity === "error" ? c("✗", "red")
+        : f.severity === "warn" ? c("⚠", "yellow")
+            : c("ℹ", "cyan");
+    consola.log(`  ${icon} ${c(f.title, "bold")}  ${c(`[${f.code}]`, "gray")}`);
+    for (const line of f.detail.split("\n")) {
+        consola.log(`     ${c(line, "dim")}`);
+    }
+    consola.log(`     ${c("→ fix:", "cyan")}`);
+    for (const line of f.fix.split("\n")) {
+        consola.log(`       ${line}`);
+    }
+    if (f.references?.length) {
+        consola.log(`     ${c("→ refs:", "dim")} ${f.references.join(", ")}`);
+    }
+    consola.log("");
+}
+function groupBy(arr, key) {
+    const out = new Map();
+    for (const v of arr) {
+        const k = key(v);
+        const bucket = out.get(k) ?? [];
+        bucket.push(v);
+        out.set(k, bucket);
+    }
+    return out;
+}
+function s(n) {
+    return n === 1 ? "" : "s";
+}
+// ─── `--last` failure diagnosis ─────────────────────────────────────────
+//
+// CK-code → one-line fix hint. Source of truth in product terms is
+// skills/creek/references/diagnosis.md; the MCP server's get_build_log
+// tool carries the same mapping (packages/mcp-server/src/tools.ts
+// CK_FIX_HINTS). Keep all three in sync when adding a new CK-* rule.
+const CK_FIX_HINTS = {
+    "CK-NO-CONFIG": "Run `creek init` to scaffold a creek.toml, or cd to a directory that contains creek.toml / wrangler.* / package.json / index.html.",
+    "CK-NOTHING-TO-DEPLOY": "Run the project's build command so there's output in [build].output, or set [build].command in creek.toml if the project needs one.",
+    "CK-DB-DUAL-DRIVER-SPLIT": "Consolidate the split db.local.ts + db.prod.ts files. Share schema.ts and routes.ts; keep only thin boot files (server/local.ts for dev, server/worker.ts for prod) that differ in driver setup. See examples/vite-react-drizzle.",
+    "CK-SYNC-SQLITE": "better-sqlite3 is synchronous and won't run on Workers. Migrate to an async ORM with a D1 adapter — Drizzle or Kysely are the drop-in paths.",
+    "CK-PRISMA-SQLITE": "Prisma's SQLite datasource isn't supported on Cloudflare Workers. Switch to Drizzle or Kysely with a D1 adapter.",
+    "CK-RUNTIME-LOCKIN": "The project imports from @solcreek/* runtime packages. For a portable build that can deploy outside Creek, replace those with driver-level imports (e.g. drizzle-orm/d1 instead of creek's db re-export).",
+    "CK-CONFIG-OVERLAP": "Both creek.toml and wrangler.* are present. Pick one as the source of truth — creek.toml is preferred; remove wrangler.* or update any shared fields to match.",
+};
+function suggestFix(code) {
+    if (!code)
+        return null;
+    return CK_FIX_HINTS[code] ?? null;
+}
+async function runLastFailureDiagnosis(opts) {
+    const token = getToken();
+    if (!token) {
+        if (opts.jsonMode) {
+            jsonOutput({ ok: false, error: "not_authenticated" }, 1, AUTH_BREADCRUMBS);
+        }
+        consola.error("Not authenticated. Run `creek login` first.");
+        process.exit(1);
+    }
+    // Resolve project slug — prefer --project, fall back to creek.toml
+    let slug = opts.project;
+    if (!slug) {
+        const creekToml = join(opts.cwd, "creek.toml");
+        if (existsSync(creekToml)) {
+            const raw = safeRead(creekToml);
+            const match = raw?.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+            if (match)
+                slug = match[1];
+        }
+    }
+    if (!slug) {
+        const msg = "No project slug. Pass --project <slug> or run from a directory with creek.toml.";
+        if (opts.jsonMode)
+            jsonOutput({ ok: false, error: "no_project", message: msg }, 1);
+        consola.error(msg);
+        process.exit(1);
+    }
+    const client = new CreekClient(getApiUrl(), token);
+    // Find the most recent failed deployment.
+    let deployments;
+    try {
+        deployments = await client.listDeployments(slug);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to list deployments";
+        if (opts.jsonMode)
+            jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+        consola.error(msg);
+        process.exit(1);
+    }
+    const failed = deployments.find((d) => d.status === "failed");
+    if (!failed) {
+        const msg = `No failed deployments for ${slug}. Last ${deployments.length} deploys succeeded.`;
+        if (opts.jsonMode)
+            jsonOutput({ ok: true, project: slug, failed: null, message: msg }, 0);
+        consola.log("");
+        consola.log(`  ${c("⬡ creek doctor --last", "bold")}  ${c(slug, "dim")}`);
+        consola.log(`  ${c("✓", "green")} ${msg}`);
+        consola.log("");
+        return;
+    }
+    // Pull the build log.
+    let log;
+    try {
+        log = await client.getBuildLog(slug, failed.id);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : "Failed to read build log";
+        if (opts.jsonMode)
+            jsonOutput({ ok: false, error: "api_error", message: msg }, 1);
+        consola.error(msg);
+        process.exit(1);
+    }
+    const meta = log.metadata;
+    const errorCode = meta?.errorCode ?? null;
+    const errorStep = meta?.errorStep ?? null;
+    const fix = suggestFix(errorCode);
+    if (opts.jsonMode) {
+        jsonOutput({
+            ok: true,
+            project: slug,
+            failed: {
+                id: failed.id,
+                version: failed.version,
+                branch: failed.branch,
+                commitSha: failed.commit_sha,
+                errorCode,
+                errorStep,
+                suggestedFix: fix,
+                failedStep: failed.failed_step,
+                errorMessage: failed.error_message,
+            },
+        }, 0, [
+            {
+                command: `creek deployments logs ${failed.id.slice(0, 8)} --json`,
+                description: "Read the full build log",
+            },
+            { command: `creek deploy --json`, description: "Redeploy after fixing" },
+        ]);
+        return;
+    }
+    // Human output.
+    consola.log("");
+    consola.log(`  ${c("⬡ creek doctor --last", "bold")}  ${c(slug, "dim")}`);
+    consola.log(`  ${c("failed deploy:", "dim")} ${failed.id.slice(0, 8)}${failed.branch ? ` (${failed.branch})` : ""}`);
+    consola.log("");
+    if (errorCode) {
+        consola.log(`  ${c("✗", "red")} ${c(errorCode, "bold")}  ${c(`at step: ${errorStep ?? "unknown"}`, "gray")}`);
+    }
+    else if (errorStep) {
+        consola.log(`  ${c("✗", "red")} Failed at step: ${c(errorStep, "bold")}`);
+    }
+    else {
+        consola.log(`  ${c("✗", "red")} Deploy failed — no structured errorCode available.`);
+    }
+    consola.log("");
+    if (fix) {
+        consola.log(`  ${c("→ fix:", "cyan")}`);
+        for (const line of fix.split("\n"))
+            consola.log(`    ${line}`);
+        consola.log("");
+    }
+    else if (errorCode) {
+        consola.log(`  ${c("→ no mapped fix for", "dim")} ${c(errorCode, "bold")}${c(". Inspect the full log:", "dim")}`);
+        consola.log(`    creek deployments logs ${failed.id.slice(0, 8)}`);
+        consola.log("");
+    }
+    else {
+        consola.log(`  ${c("→ inspect the full log:", "cyan")}`);
+        consola.log(`    creek deployments logs ${failed.id.slice(0, 8)}`);
+        consola.log("");
+    }
+    if (failed.error_message) {
+        consola.log(`  ${c("error message:", "dim")}`);
+        for (const line of failed.error_message.split("\n").slice(0, 8)) {
+            consola.log(`    ${c(line, "gray")}`);
+        }
+        consola.log("");
+    }
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/migrate.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Migration logic for `creek db migrate`.
+ *
+ * Pure functions are exported for testing. The CLI command wires
+ * them together with the SDK client in db.ts.
+ */
+/**
+ * Find the migration directory relative to cwd.
+ * Returns the absolute path of the first candidate that exists and
+ * contains at least one .sql file, or null if none found.
+ */
+export declare function detectMigrationDir(cwd: string): string | null;
+export interface MigrationFile {
+    /** File name without directory (e.g. "0001_init.sql") */
+    name: string;
+    /** Absolute path */
+    path: string;
+}
+/**
+ * Read .sql files from a directory, sorted lexicographically.
+ * Non-.sql files and empty .sql files are skipped.
+ */
+export declare function parseMigrationFiles(dir: string): MigrationFile[];
+/**
+ * Split a migration file's SQL content into individual statements.
+ *
+ * If the content contains Drizzle's `--> statement-breakpoint` marker,
+ * split on those. Otherwise split on semicolons. Empty statements are
+ * filtered out.
+ */
+export declare function splitStatements(sql: string): string[];
+/**
+ * Given files on disk and names already applied, return the pending
+ * migrations in order.
+ */
+export declare function computePending(files: MigrationFile[], applied: Set<string>): MigrationFile[];
+//# sourceMappingURL=migrate.d.ts.map