vibeorm 0.1.0

package/README.md

@@ -0,0 +1,96 @@
+# vibeorm
+
+CLI for VibeORM — generate clients, run migrations, and manage your PostgreSQL database.
+
+## Installation
+
+```bash
+bun add -d vibeorm
+```
+
+## Commands
+
+```bash
+bunx vibeorm <command> [options]
+```
+
+### Code Generation
+
+| Command | Description |
+|---------|-------------|
+| `generate` | Parse `.prisma` schema and generate TypeScript client files |
+
+### Database Management
+
+| Command | Description |
+|---------|-------------|
+| `db push` | Diff schema against database and apply changes |
+| `db pull` | Introspect database and write `.prisma` schema |
+| `db reset` | Drop schema, re-apply migrations, optionally seed |
+| `db seed` | Run configured seed script |
+| `db execute` | Execute a raw SQL file |
+
+Options for `db push`: `--force`, `--accept-data-loss`, `--dry-run`
+Options for `db pull`: `--print`
+Options for `db reset`: `--force` (required), `--skip-seed`
+Options for `db execute`: `--file <path>`
+
+### Migrations
+
+| Command | Description |
+|---------|-------------|
+| `migrate generate` | Create migration SQL from schema diff |
+| `migrate apply` | Apply pending migrations |
+| `migrate status` | Show applied vs pending migrations |
+| `migrate resolve` | Repair migration state |
+
+Options for `migrate generate`: `--name <name>`, `--dry-run`
+Options for `migrate apply`: `--dry-run`
+Options for `migrate resolve`: `--applied <name>`, `--rolled-back <name>`
+
+### Global Options
+
+All commands accept:
+
+- `--schema <path>` — path to `.prisma` schema file or directory
+- `--output <path>` — output directory for generated files
+- `--migrations <path>` — migrations directory
+- `--seed <path>` — seed script path
+- `--url <postgres-url>` — database connection string
+
+## Configuration
+
+Config priority (last wins):
+
+1. Defaults (`./prisma/schema.prisma`, `./generated/vibeorm`, `./migrations`)
+2. `package.json` `vibeorm` key
+3. `vibeorm.config.ts`
+4. CLI flags
+
+### package.json
+
+```json
+{
+  "vibeorm": {
+    "schema": "./prisma/schema.prisma",
+    "output": "./generated/vibeorm",
+    "migrations": "./migrations",
+    "seed": "./prisma/seed.ts"
+  }
+}
+```
+
+### vibeorm.config.ts
+
+```ts
+export const config = {
+  schema: "./prisma/schema.prisma",
+  output: "./generated/vibeorm",
+  migrations: "./migrations",
+  seed: "./prisma/seed.ts",
+};
+```
+
+## License
+
+[MIT](../../LICENSE)

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "vibeorm",
+  "version": "0.1.0",
+  "description": "CLI for VibeORM — generate clients, run migrations, introspect databases",
+  "license": "MIT",
+  "keywords": ["orm", "cli", "prisma", "postgresql", "bun", "typescript", "migrations"],
+  "type": "module",
+  "bin": {
+    "vibeorm": "./src/index.ts"
+  },
+  "exports": {
+    ".": {
+    "default": "./src/index.ts",
+    "types": "./src/index.ts"
+  }
+},
+"files": ["src"],
+"repository": {
+  "type": "git",
+  "url": "https://github.com/vibeorm/vibeorm.git",
+  "directory": "packages/cli"
+},
+"homepage": "https://github.com/vibeorm/vibeorm",
+"bugs": {
+  "url": "https://github.com/vibeorm/vibeorm/issues"
+},
+"publishConfig": {
+  "access": "public"
+},
+"engines": {
+  "bun": ">=1.1.0"
+},
+"dependencies": {
+  "@vibeorm/parser": "0.1.0",
+  "@vibeorm/generator": "0.1.0",
+  "@vibeorm/migrate": "0.1.0",
+  "@vibeorm/runtime": "0.1.0",
+  "@vibeorm/adapter-bun": "0.1.0"
+}
+}

package/src/commands/db-execute.ts

@@ -0,0 +1,44 @@
+/**
+ * vibeorm db execute
+ *
+ * Execute a raw .sql file against the database.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import type { VibeOrmConfig } from "../config.ts";
+import { createConnection } from "../connection.ts";
+
+export async function runDbExecute(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { flags } = params;
+
+  const filePath = flags.file;
+  if (!filePath) {
+    console.error("Error: --file <path> is required.");
+    console.error("Usage: vibeorm db execute --file ./scripts/cleanup.sql");
+    process.exit(1);
+  }
+
+  if (!existsSync(filePath)) {
+    console.error(`Error: SQL file not found at ${filePath}`);
+    process.exit(1);
+  }
+
+  console.log("VibeORM DB Execute");
+  console.log(`  File: ${filePath}`);
+  console.log("");
+
+  const sql = readFileSync(filePath, "utf-8");
+  const conn = createConnection({ url: flags.url });
+
+  try {
+    console.log("Executing SQL...");
+    const result = await conn.executor({ text: sql });
+    console.log(`Executed successfully. Rows returned: ${result.length}`);
+    console.log("Done!");
+  } finally {
+    await conn.close();
+  }
+}

package/src/commands/db-pull.ts

@@ -0,0 +1,57 @@
+/**
+ * vibeorm db pull
+ *
+ * Introspect an existing PostgreSQL database and generate a .prisma schema file.
+ */
+
+import { introspect, printSchema } from "@vibeorm/migrate";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import type { VibeOrmConfig } from "../config.ts";
+import { createConnection } from "../connection.ts";
+
+export async function runDbPull(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config, flags } = params;
+
+  const printToStdout = flags.print === "true";
+  const outputPath = flags.schema ?? config.schema;
+
+  console.log("VibeORM DB Pull");
+  console.log("");
+
+  // Connect to database
+  const conn = createConnection({ url: flags.url });
+
+  try {
+    // Introspect
+    console.log("Introspecting database...");
+    const schema = await introspect({ executor: conn.executor });
+
+    console.log(`Found ${schema.models.length} models, ${schema.enums.length} enums`);
+
+    // Convert to .prisma text
+    const prismaText = printSchema({ schema });
+
+    if (printToStdout) {
+      console.log("");
+      console.log(prismaText);
+      return;
+    }
+
+    // Write to file
+    const dir = dirname(outputPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    writeFileSync(outputPath, prismaText, "utf-8");
+    console.log("");
+    console.log(`Schema written to ${outputPath}`);
+    console.log("Done!");
+  } finally {
+    await conn.close();
+  }
+}

package/src/commands/db-push.ts

@@ -0,0 +1,120 @@
+/**
+ * vibeorm db push
+ *
+ * Push schema directly to database (prototyping, no migration files).
+ *
+ * Flow:
+ * 1. Parse .prisma schema → IR
+ * 2. Connect to PostgreSQL
+ * 3. Introspect current database state → IR
+ * 4. Diff the two IRs → DDL operations
+ * 5. Classify as safe/destructive
+ * 6. If destructive, require --force or --accept-data-loss
+ * 7. Execute DDL in a transaction
+ */
+
+import { parsePrismaSchema, validateSchema, formatValidationErrors } from "@vibeorm/parser";
+import { introspect, diffSchemas, buildDDL, splitSqlStatements } from "@vibeorm/migrate";
+import type { DiffOperation } from "@vibeorm/migrate";
+import type { VibeOrmConfig } from "../config.ts";
+import { createConnection } from "../connection.ts";
+import { loadSchemaSource } from "../schema-loader.ts";
+
+export async function runDbPush(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config, flags } = params;
+
+  const force = flags.force === "true" || flags["accept-data-loss"] === "true";
+  const dryRun = flags["dry-run"] === "true";
+
+  console.log("VibeORM DB Push");
+  console.log(`  Schema: ${config.schema}`);
+  console.log("");
+
+  // 1. Parse schema (file or directory)
+  const source = loadSchemaSource({ schemaPath: config.schema });
+  const currentSchema = parsePrismaSchema({ source });
+  console.log(`Parsed ${currentSchema.models.length} models, ${currentSchema.enums.length} enums`);
+
+  // Validate schema
+  const validation = validateSchema({ schema: currentSchema });
+  if (!validation.valid) {
+    console.error("");
+    console.error(formatValidationErrors({ result: validation }));
+    process.exit(1);
+  }
+  if (validation.warnings.length > 0) {
+    console.warn("");
+    console.warn(formatValidationErrors({ result: validation }));
+    console.warn("");
+  }
+
+  // 2. Connect to database
+  const conn = createConnection({ url: flags.url });
+
+  try {
+    // 3. Introspect database
+    console.log("Introspecting database...");
+    const dbSchema = await introspect({ executor: conn.executor });
+    console.log(`Found ${dbSchema.models.length} existing tables`);
+
+    // 4. Diff schemas
+    const operations = diffSchemas({ previous: dbSchema, current: currentSchema });
+
+    if (operations.length === 0) {
+      console.log("");
+      console.log("Database is already in sync with the schema. No changes needed.");
+      return;
+    }
+
+    // 5. Classify operations
+    const safeOps = operations.filter((op: DiffOperation) => !op.isDestructive);
+    const destructiveOps = operations.filter((op: DiffOperation) => op.isDestructive);
+
+    console.log("");
+    console.log(`Changes detected: ${safeOps.length} safe, ${destructiveOps.length} destructive`);
+    console.log("");
+
+    // Print all operations
+    for (const op of operations) {
+      const prefix = op.isDestructive ? "[DESTRUCTIVE]" : "[SAFE]";
+      console.log(`  ${prefix} ${op.description}`);
+    }
+
+    // 6. Check for destructive operations
+    if (destructiveOps.length > 0 && !force) {
+      console.log("");
+      console.error("Error: Destructive changes detected.");
+      console.error("Use --force or --accept-data-loss to apply these changes.");
+      process.exit(1);
+    }
+
+    // 7. Generate and execute DDL
+    // Each operation's sql may contain multiple statements (e.g. join tables).
+    // We need to split them carefully — DO $$ blocks contain semicolons internally.
+    const allStatements: string[] = [];
+    for (const op of operations) {
+      splitSqlStatements({ sql: op.sql }).forEach((stmt: string) => allStatements.push(stmt));
+    }
+
+    if (dryRun) {
+      console.log("");
+      console.log("=== DRY RUN — SQL that would be executed ===");
+      console.log("");
+      console.log(allStatements.join("\n\n"));
+      return;
+    }
+
+    console.log("");
+    console.log("Applying changes...");
+    await conn.executeInTransaction({ statements: allStatements });
+
+    console.log("");
+    console.log(`Applied ${operations.length} changes successfully.`);
+    console.log("Database is now in sync with the schema.");
+  } finally {
+    await conn.close();
+  }
+}

package/src/commands/db-reset.ts

@@ -0,0 +1,110 @@
+/**
+ * vibeorm db reset
+ *
+ * Drop all tables + re-apply all migrations + seed.
+ */
+
+import {
+  ensureMigrationTable,
+  getAppliedMigrations,
+  applyMigration,
+  loadJournal,
+  computeChecksum,
+} from "@vibeorm/migrate";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import type { VibeOrmConfig } from "../config.ts";
+import { createConnection } from "../connection.ts";
+
+export async function runDbReset(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config, flags } = params;
+
+  const force = flags.force === "true";
+  const skipSeed = flags["skip-seed"] === "true";
+
+  if (!force) {
+    console.log("WARNING: This will drop all tables in the public schema and re-apply all migrations.");
+    console.log("Use --force to skip this confirmation.");
+    console.log("");
+    console.error("Aborted. Use --force to proceed.");
+    process.exit(1);
+  }
+
+  console.log("VibeORM DB Reset");
+  console.log("");
+
+  const conn = createConnection({ url: flags.url });
+
+  try {
+    // 1. Drop everything in public schema
+    console.log("Dropping all tables and types...");
+    await conn.executor({ text: "DROP SCHEMA public CASCADE;" });
+    await conn.executor({ text: "CREATE SCHEMA public;" });
+    console.log("Schema dropped and recreated.");
+
+    // 2. Re-apply all migrations
+    console.log("");
+    console.log("Re-applying migrations...");
+
+    await ensureMigrationTable({ executor: conn.executor });
+
+    const journal = loadJournal({ migrationsDir: config.migrations });
+
+    if (journal.entries.length === 0) {
+      console.log("No migrations found to apply.");
+    } else {
+      for (const entry of journal.entries) {
+        const migrationDir = join(config.migrations, `${entry.timestamp}_${entry.name}`);
+        const sqlPath = join(migrationDir, "migration.sql");
+
+        if (!existsSync(sqlPath)) {
+          console.error(`Error: Migration file not found: ${sqlPath}`);
+          process.exit(1);
+        }
+
+        const sql = readFileSync(sqlPath, "utf-8");
+        const checksum = computeChecksum({ content: sql });
+
+        console.log(`  Applying ${entry.timestamp}_${entry.name}...`);
+        const result = await applyMigration({
+          executor: conn.executor,
+          migrationName: `${entry.timestamp}_${entry.name}`,
+          sql,
+          checksum,
+        });
+        console.log(`    Done in ${result.executionTime}ms`);
+      }
+
+      console.log(`Applied ${journal.entries.length} migrations.`);
+    }
+
+    // 3. Run seed
+    if (!skipSeed && config.seed) {
+      console.log("");
+      console.log("Running seed...");
+
+      if (!existsSync(config.seed)) {
+        console.warn(`Warning: Seed file not found at ${config.seed}. Skipping.`);
+      } else {
+        const proc = Bun.spawn(["bun", "run", config.seed], {
+          stdout: "inherit",
+          stderr: "inherit",
+        });
+        const exitCode = await proc.exited;
+        if (exitCode !== 0) {
+          console.error(`Seed script exited with code ${exitCode}`);
+          process.exit(1);
+        }
+        console.log("Seed completed.");
+      }
+    }
+
+    console.log("");
+    console.log("Database reset complete.");
+  } finally {
+    await conn.close();
+  }
+}

package/src/commands/db-seed.ts

@@ -0,0 +1,48 @@
+/**
+ * vibeorm db seed
+ *
+ * Run a user-defined seed script.
+ */
+
+import { existsSync } from "fs";
+import type { VibeOrmConfig } from "../config.ts";
+
+export async function runDbSeed(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config } = params;
+
+  console.log("VibeORM DB Seed");
+  console.log("");
+
+  // Resolve seed path
+  const seedPath = config.seed;
+  if (!seedPath) {
+    console.error("Error: No seed script configured.");
+    console.error("Set 'seed' in vibeorm.config.ts, package.json vibeorm.seed, or use --seed <path>.");
+    process.exit(1);
+  }
+
+  if (!existsSync(seedPath)) {
+    console.error(`Error: Seed file not found at ${seedPath}`);
+    process.exit(1);
+  }
+
+  console.log(`Running seed: ${seedPath}`);
+  console.log("");
+
+  const proc = Bun.spawn(["bun", "run", seedPath], {
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    console.error(`Seed script exited with code ${exitCode}`);
+    process.exit(1);
+  }
+
+  console.log("");
+  console.log("Seed completed.");
+}

package/src/commands/generate.ts

@@ -0,0 +1,64 @@
+/**
+ * vibeorm generate
+ *
+ * Parse .prisma schema → generate TypeScript client files.
+ */
+
+import { parsePrismaSchema, validateSchema, formatValidationErrors } from "@vibeorm/parser";
+import { generate } from "@vibeorm/generator";
+import { join } from "path";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import type { VibeOrmConfig } from "../config.ts";
+import { loadSchemaSource } from "../schema-loader.ts";
+
+export async function runGenerate(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config } = params;
+
+  console.log("VibeORM Generate");
+  console.log(`  Schema: ${config.schema}`);
+  console.log(`  Output: ${config.output}`);
+  console.log("");
+
+  // Read schema (file or directory)
+  const source = loadSchemaSource({ schemaPath: config.schema });
+
+  // Parse
+  console.log("Parsing schema...");
+  const schema = parsePrismaSchema({ source });
+  console.log(`  Found ${schema.models.length} models, ${schema.enums.length} enums`);
+
+  // Validate
+  const validation = validateSchema({ schema });
+  if (!validation.valid) {
+    console.error("");
+    console.error(formatValidationErrors({ result: validation }));
+    process.exit(1);
+  }
+  if (validation.warnings.length > 0) {
+    console.warn("");
+    console.warn(formatValidationErrors({ result: validation }));
+    console.warn("");
+  }
+
+  // Generate
+  console.log("Generating client...");
+  const files = generate({ schema });
+
+  // Write files
+  if (!existsSync(config.output)) {
+    mkdirSync(config.output, { recursive: true });
+  }
+
+  for (const file of files) {
+    const filePath = join(config.output, file.filename);
+    writeFileSync(filePath, file.content, "utf-8");
+    console.log(`  Written: ${file.filename}`);
+  }
+
+  console.log("");
+  console.log(`Generated ${files.length} files in ${config.output}`);
+  console.log("Done!");
+}

package/src/commands/migrate-apply.ts

@@ -0,0 +1,119 @@
+/**
+ * vibeorm migrate apply
+ *
+ * Apply all pending migrations to the database.
+ */
+
+import {
+  ensureMigrationTable,
+  getAppliedMigrations,
+  applyMigration,
+  loadJournal,
+  computeChecksum,
+} from "@vibeorm/migrate";
+import type { AppliedMigration, JournalEntry } from "@vibeorm/migrate";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import type { VibeOrmConfig } from "../config.ts";
+import { createConnection } from "../connection.ts";
+
+export async function runMigrateApply(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config, flags } = params;
+  const dryRun = flags["dry-run"] === "true";
+
+  console.log("VibeORM Migrate Apply");
+  console.log(`  Migrations: ${config.migrations}`);
+  console.log("");
+
+  // 1. Load journal
+  const journal = loadJournal({ migrationsDir: config.migrations });
+  if (journal.entries.length === 0) {
+    console.log("No migrations found. Run 'vibeorm migrate generate' first.");
+    return;
+  }
+
+  // 2. Connect to database
+  const conn = createConnection({ url: flags.url });
+
+  try {
+    // 3. Ensure migration table
+    await ensureMigrationTable({ executor: conn.executor });
+
+    // 4. Get applied migrations
+    const applied = await getAppliedMigrations({ executor: conn.executor });
+    const appliedSet = new Map(applied.map((m: AppliedMigration) => [m.migrationName, m]));
+
+    // 5. Find pending migrations
+    const pending: JournalEntry[] = [];
+    for (const entry of journal.entries) {
+      const migrationName = `${entry.timestamp}_${entry.name}`;
+      const appliedMigration = appliedSet.get(migrationName);
+
+      if (appliedMigration) {
+        // Check for checksum mismatch
+        const sqlPath = join(config.migrations, migrationName, "migration.sql");
+        if (existsSync(sqlPath)) {
+          const sql = readFileSync(sqlPath, "utf-8");
+          const currentChecksum = computeChecksum({ content: sql });
+          if (currentChecksum !== appliedMigration.checksum) {
+            console.warn(`  WARNING: Checksum mismatch for ${migrationName}`);
+            console.warn(`    Expected: ${appliedMigration.checksum}`);
+            console.warn(`    Current:  ${currentChecksum}`);
+            console.warn("    The migration file has been modified after being applied.");
+          }
+        }
+        continue;
+      }
+
+      pending.push(entry);
+    }
+
+    if (pending.length === 0) {
+      console.log("All migrations are already applied. Database is up to date.");
+      return;
+    }
+
+    console.log(`Found ${pending.length} pending migration(s):`);
+    for (const entry of pending) {
+      console.log(`  - ${entry.timestamp}_${entry.name}`);
+    }
+
+    if (dryRun) {
+      console.log("");
+      console.log("DRY RUN — No changes applied.");
+      return;
+    }
+
+    // 6. Apply pending migrations in order
+    console.log("");
+    for (const entry of pending) {
+      const migrationName = `${entry.timestamp}_${entry.name}`;
+      const sqlPath = join(config.migrations, migrationName, "migration.sql");
+
+      if (!existsSync(sqlPath)) {
+        console.error(`Error: Migration file not found: ${sqlPath}`);
+        process.exit(1);
+      }
+
+      const sql = readFileSync(sqlPath, "utf-8");
+      const checksum = computeChecksum({ content: sql });
+
+      console.log(`Applying ${migrationName}...`);
+      const result = await applyMigration({
+        executor: conn.executor,
+        migrationName,
+        sql,
+        checksum,
+      });
+      console.log(`  Done in ${result.executionTime}ms`);
+    }
+
+    console.log("");
+    console.log(`Applied ${pending.length} migration(s) successfully.`);
+  } finally {
+    await conn.close();
+  }
+}

package/src/commands/migrate-generate.ts

@@ -0,0 +1,134 @@
+/**
+ * vibeorm migrate generate
+ *
+ * Diff the current .prisma schema against the last snapshot
+ * and generate a migration .sql file. Does NOT require a database connection.
+ */
+
+import { parsePrismaSchema, validateSchema, formatValidationErrors } from "@vibeorm/parser";
+import {
+  diffSchemas,
+  buildDDL,
+  loadLatestSnapshot,
+  saveSnapshot,
+  loadJournal,
+  saveJournal,
+  generateTimestamp,
+  computeChecksum,
+} from "@vibeorm/migrate";
+import type { DiffOperation, Journal, JournalEntry } from "@vibeorm/migrate";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { VibeOrmConfig } from "../config.ts";
+import { loadSchemaSource } from "../schema-loader.ts";
+
+export async function runMigrateGenerate(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config, flags } = params;
+
+  const migrationName = flags.name ?? "migration";
+  const dryRun = flags["dry-run"] === "true";
+
+  console.log("VibeORM Migrate Generate");
+  console.log(`  Schema: ${config.schema}`);
+  console.log(`  Migrations: ${config.migrations}`);
+  console.log("");
+
+  // 1. Parse current schema (file or directory)
+  const source = loadSchemaSource({ schemaPath: config.schema });
+  const currentSchema = parsePrismaSchema({ source });
+  console.log(`Parsed ${currentSchema.models.length} models, ${currentSchema.enums.length} enums`);
+
+  // Validate schema
+  const validation = validateSchema({ schema: currentSchema });
+  if (!validation.valid) {
+    console.error("");
+    console.error(formatValidationErrors({ result: validation }));
+    process.exit(1);
+  }
+  if (validation.warnings.length > 0) {
+    console.warn("");
+    console.warn(formatValidationErrors({ result: validation }));
+    console.warn("");
+  }
+
+  // 2. Load latest snapshot (previous state)
+  const previousSchema = loadLatestSnapshot({ migrationsDir: config.migrations });
+  const emptySchema = { models: [], enums: [] };
+  const prevSchema = previousSchema ?? emptySchema;
+
+  if (!previousSchema) {
+    console.log("No previous snapshot found. This will be the initial migration.");
+  }
+
+  // 3. Diff schemas
+  const operations = diffSchemas({ previous: prevSchema, current: currentSchema });
+
+  if (operations.length === 0) {
+    console.log("");
+    console.log("No changes detected. Schema is up to date.");
+    return;
+  }
+
+  // 4. Generate SQL
+  let migrationSql: string;
+  if (!previousSchema) {
+    // First migration: use buildDDL for a clean full schema creation
+    const ddl = buildDDL({ schema: currentSchema });
+    migrationSql = ddl.statements.join("\n\n");
+  } else {
+    // Incremental migration: use diff operations
+    migrationSql = operations.map((op: DiffOperation) => op.sql).join("\n\n");
+  }
+
+  // Print summary
+  console.log("");
+  console.log("Changes:");
+  for (const op of operations) {
+    const prefix = op.isDestructive ? "[!]" : "[+]";
+    console.log(`  ${prefix} ${op.description}`);
+  }
+
+  if (dryRun) {
+    console.log("");
+    console.log("=== DRY RUN — SQL that would be generated ===");
+    console.log("");
+    console.log(migrationSql);
+    return;
+  }
+
+  // 5. Create migration files
+  const timestamp = generateTimestamp();
+  const dirName = `${timestamp}_${migrationName}`;
+  const migrationDir = join(config.migrations, dirName);
+  const sqlPath = join(migrationDir, "migration.sql");
+
+  mkdirSync(migrationDir, { recursive: true });
+  writeFileSync(sqlPath, migrationSql, "utf-8");
+
+  // 6. Save snapshot
+  saveSnapshot({ schema: currentSchema, migrationsDir: config.migrations, timestamp });
+
+  // 7. Update journal
+  const checksum = computeChecksum({ content: migrationSql });
+  const journal = loadJournal({ migrationsDir: config.migrations });
+
+  const entry: JournalEntry = {
+    idx: journal.entries.length,
+    timestamp,
+    name: migrationName,
+    checksum,
+  };
+
+  journal.entries.push(entry);
+  saveJournal({ migrationsDir: config.migrations, journal });
+
+  console.log("");
+  console.log(`Created migration: ${dirName}`);
+  console.log(`  SQL: ${sqlPath}`);
+  console.log("");
+  console.log("Generated SQL:");
+  console.log(migrationSql);
+}

package/src/commands/migrate-resolve.ts

@@ -0,0 +1,89 @@
+/**
+ * vibeorm migrate resolve
+ *
+ * Repair tool for when migrations get into a bad state.
+ *
+ * --applied <name>     Mark a migration as already applied (without running it)
+ * --rolled-back <name> Remove a migration record from tracking table
+ */
+
+import {
+  ensureMigrationTable,
+  markMigrationApplied,
+  removeMigrationRecord,
+  loadJournal,
+  computeChecksum,
+} from "@vibeorm/migrate";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import type { VibeOrmConfig } from "../config.ts";
+import { createConnection } from "../connection.ts";
+
+export async function runMigrateResolve(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config, flags } = params;
+
+  const appliedName = flags.applied;
+  const rolledBackName = flags["rolled-back"];
+
+  if (!appliedName && !rolledBackName) {
+    console.error("Error: Specify either --applied <name> or --rolled-back <name>");
+    console.error("");
+    console.error("Usage:");
+    console.error("  vibeorm migrate resolve --applied 20250206140000_init");
+    console.error("  vibeorm migrate resolve --rolled-back 20250206140000_init");
+    process.exit(1);
+  }
+
+  if (appliedName && rolledBackName) {
+    console.error("Error: Cannot use both --applied and --rolled-back at the same time.");
+    process.exit(1);
+  }
+
+  console.log("VibeORM Migrate Resolve");
+  console.log("");
+
+  const conn = createConnection({ url: flags.url });
+
+  try {
+    await ensureMigrationTable({ executor: conn.executor });
+
+    if (appliedName) {
+      // Mark as applied
+      const sqlPath = join(config.migrations, appliedName, "migration.sql");
+      let checksum = "sha256:manual";
+
+      if (existsSync(sqlPath)) {
+        const sql = readFileSync(sqlPath, "utf-8");
+        checksum = computeChecksum({ content: sql });
+      } else {
+        console.warn(`Warning: Migration file not found at ${sqlPath}`);
+        console.warn("Using placeholder checksum.");
+      }
+
+      await markMigrationApplied({
+        executor: conn.executor,
+        migrationName: appliedName,
+        checksum,
+      });
+
+      console.log(`Marked "${appliedName}" as applied.`);
+    }
+
+    if (rolledBackName) {
+      // Remove from tracking
+      await removeMigrationRecord({
+        executor: conn.executor,
+        migrationName: rolledBackName,
+      });
+
+      console.log(`Removed "${rolledBackName}" from migration tracking.`);
+    }
+
+    console.log("Done!");
+  } finally {
+    await conn.close();
+  }
+}

package/src/commands/migrate-status.ts

@@ -0,0 +1,101 @@
+/**
+ * vibeorm migrate status
+ *
+ * Show which migrations are applied and which are pending.
+ */
+
+import {
+  ensureMigrationTable,
+  getAppliedMigrations,
+  loadJournal,
+  computeChecksum,
+} from "@vibeorm/migrate";
+import type { AppliedMigration } from "@vibeorm/migrate";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import type { VibeOrmConfig } from "../config.ts";
+import { createConnection } from "../connection.ts";
+
+export async function runMigrateStatus(params: {
+  config: VibeOrmConfig;
+  flags: Record<string, string>;
+}): Promise<void> {
+  const { config, flags } = params;
+
+  console.log("VibeORM Migrate Status");
+  console.log(`  Migrations: ${config.migrations}`);
+  console.log("");
+
+  // Load journal
+  const journal = loadJournal({ migrationsDir: config.migrations });
+
+  if (journal.entries.length === 0) {
+    console.log("No migrations found.");
+    return;
+  }
+
+  // Connect to database
+  const conn = createConnection({ url: flags.url });
+
+  try {
+    await ensureMigrationTable({ executor: conn.executor });
+    const applied = await getAppliedMigrations({ executor: conn.executor });
+    const appliedMap = new Map(applied.map((m: AppliedMigration) => [m.migrationName, m]));
+
+    // Print header
+    const nameWidth = 45;
+    const statusWidth = 15;
+    const dateWidth = 22;
+
+    console.log(
+      "Migration".padEnd(nameWidth) +
+      "Status".padEnd(statusWidth) +
+      "Applied At"
+    );
+    console.log("-".repeat(nameWidth + statusWidth + dateWidth));
+
+    // Print each migration
+    for (const entry of journal.entries) {
+      const migrationName = `${entry.timestamp}_${entry.name}`;
+      const appliedMigration = appliedMap.get(migrationName);
+
+      let status: string;
+      let appliedAt: string;
+
+      if (appliedMigration) {
+        status = "Applied";
+        appliedAt = appliedMigration.appliedAt.toISOString().replace("T", " ").slice(0, 19);
+
+        // Check for checksum mismatch
+        const sqlPath = join(config.migrations, migrationName, "migration.sql");
+        if (existsSync(sqlPath)) {
+          const sql = readFileSync(sqlPath, "utf-8");
+          const currentChecksum = computeChecksum({ content: sql });
+          if (currentChecksum !== appliedMigration.checksum) {
+            status = "Modified!";
+          }
+        }
+      } else {
+        status = "Pending";
+        appliedAt = "-";
+      }
+
+      console.log(
+        migrationName.padEnd(nameWidth) +
+        status.padEnd(statusWidth) +
+        appliedAt
+      );
+    }
+
+    // Summary
+    const pendingCount = journal.entries.filter(
+      (e) => !appliedMap.has(`${e.timestamp}_${e.name}`)
+    ).length;
+    const appliedCount = journal.entries.length - pendingCount;
+
+    console.log("");
+    console.log(`Total: ${journal.entries.length} migrations (${appliedCount} applied, ${pendingCount} pending)`);
+  } finally {
+    await conn.close();
+  }
+}

package/src/config.ts

@@ -0,0 +1,107 @@
+/**
+ * Unified config resolution for the VibeORM CLI.
+ *
+ * Priority (later overrides earlier):
+ *   1. Defaults
+ *   2. package.json → vibeorm key
+ *   3. vibeorm.config.ts file (if exists)
+ *   4. CLI flags (--schema, --output, etc.)
+ */
+
+import { resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+
+export type VibeOrmConfig = {
+  schema: string;
+  output: string;
+  migrations: string;
+  seed?: string;
+};
+
+const DEFAULTS: VibeOrmConfig = {
+  schema: "./prisma/schema.prisma",
+  output: "./generated/vibeorm",
+  migrations: "./migrations",
+};
+
+export function parseFlags(params: { args: string[] }): Record<string, string> {
+  const { args } = params;
+  const flags: Record<string, string> = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg.startsWith("--") && args[i + 1] && !args[i + 1]!.startsWith("--")) {
+      flags[arg.slice(2)] = args[i + 1]!;
+      i++;
+    } else if (arg.startsWith("--")) {
+      // Boolean flag like --force, --dry-run
+      flags[arg.slice(2)] = "true";
+    }
+  }
+  return flags;
+}
+
+function loadPackageJsonConfig(): Partial<VibeOrmConfig> {
+  const pkgJsonPath = resolve(process.cwd(), "package.json");
+  if (!existsSync(pkgJsonPath)) return {};
+
+  try {
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+    if (pkgJson.vibeorm && typeof pkgJson.vibeorm === "object") {
+      return pkgJson.vibeorm as Partial<VibeOrmConfig>;
+    }
+  } catch {
+    // Ignore parse errors
+  }
+  return {};
+}
+
+async function loadConfigFile(): Promise<Partial<VibeOrmConfig>> {
+  const configPath = resolve(process.cwd(), "vibeorm.config.ts");
+  if (!existsSync(configPath)) return {};
+
+  try {
+    const mod = await import(configPath);
+    const config = mod.default ?? mod;
+    if (config && typeof config === "object") {
+      return config as Partial<VibeOrmConfig>;
+    }
+  } catch {
+    // Ignore import errors
+  }
+  return {};
+}
+
+export async function resolveConfig(params: { flags?: Record<string, string> }): Promise<VibeOrmConfig> {
+  const { flags = {} } = params;
+
+  // 1. Start with defaults
+  const config: VibeOrmConfig = { ...DEFAULTS };
+
+  // 2. Merge package.json config
+  const pkgConfig = loadPackageJsonConfig();
+  if (pkgConfig.schema) config.schema = pkgConfig.schema;
+  if (pkgConfig.output) config.output = pkgConfig.output;
+  if (pkgConfig.migrations) config.migrations = pkgConfig.migrations;
+  if (pkgConfig.seed) config.seed = pkgConfig.seed;
+
+  // 3. Merge vibeorm.config.ts
+  const fileConfig = await loadConfigFile();
+  if (fileConfig.schema) config.schema = fileConfig.schema;
+  if (fileConfig.output) config.output = fileConfig.output;
+  if (fileConfig.migrations) config.migrations = fileConfig.migrations;
+  if (fileConfig.seed) config.seed = fileConfig.seed;
+
+  // 4. Merge CLI flags (highest priority)
+  if (flags.schema) config.schema = flags.schema;
+  if (flags.output) config.output = flags.output;
+  if (flags.migrations) config.migrations = flags.migrations;
+  if (flags.seed) config.seed = flags.seed;
+
+  // Resolve all paths relative to cwd
+  return {
+    schema: resolve(process.cwd(), config.schema),
+    output: resolve(process.cwd(), config.output),
+    migrations: resolve(process.cwd(), config.migrations),
+    seed: config.seed ? resolve(process.cwd(), config.seed) : undefined,
+  };
+}

package/src/connection.ts

@@ -0,0 +1,48 @@
+/**
+ * Database connection helper for CLI commands.
+ *
+ * Creates a database adapter and wraps it in an SqlExecutor
+ * compatible with @vibeorm/migrate modules.
+ */
+
+import type { SqlExecutor } from "@vibeorm/migrate";
+import { bunAdapter } from "@vibeorm/adapter-bun";
+import { toSqlExecutor } from "@vibeorm/runtime";
+import type { DatabaseAdapter } from "@vibeorm/runtime";
+
+export type Connection = {
+  executor: SqlExecutor;
+  /** Execute multiple SQL statements in a transaction */
+  executeInTransaction: (params: { statements: string[] }) => Promise<void>;
+  close: () => Promise<void>;
+};
+
+export function createConnection(params: { url?: string }): Connection {
+  const { url } = params;
+  const dbUrl = url ?? process.env.DATABASE_URL;
+
+  if (!dbUrl) {
+    console.error("Error: No database URL provided.");
+    console.error("Set DATABASE_URL environment variable or use --url flag.");
+    process.exit(1);
+  }
+
+  const adapter = bunAdapter({ url: dbUrl });
+  const executor = toSqlExecutor({ adapter });
+
+  const executeInTransaction = async (txParams: { statements: string[] }) => {
+    await adapter.transaction(async (txAdapter) => {
+      for (const stmt of txParams.statements) {
+        if (stmt.trim()) {
+          await txAdapter.executeUnsafe({ text: stmt });
+        }
+      }
+    });
+  };
+
+  return {
+    executor,
+    executeInTransaction,
+    close: () => adapter.disconnect(),
+  };
+}

package/src/index.ts

@@ -0,0 +1,110 @@
+#!/usr/bin/env bun
+
+/**
+ * VibeORM CLI
+ *
+ * Usage:
+ *   vibeorm generate                        Parse .prisma → generate TypeScript client
+ *   vibeorm db push [--force] [--accept-data-loss] [--dry-run]   Push schema directly to DB
+ *   vibeorm db pull [--print]               Introspect DB → generate .prisma schema
+ *   vibeorm db reset [--force] [--skip-seed] Drop all + re-apply migrations + seed
+ *   vibeorm db seed                         Run seed script
+ *   vibeorm db execute --file <path>        Execute raw .sql file
+ *   vibeorm migrate generate [--name <n>] [--dry-run]   Generate migration from schema diff
+ *   vibeorm migrate apply [--dry-run]       Apply pending migrations
+ *   vibeorm migrate status                  Show migration state
+ *   vibeorm migrate resolve --applied <name> | --rolled-back <name>   Repair migration state
+ */
+
+import { resolveConfig, parseFlags } from "./config.ts";
+import type { VibeOrmConfig } from "./config.ts";
+
+import { runGenerate } from "./commands/generate.ts";
+import { runDbPush } from "./commands/db-push.ts";
+import { runDbPull } from "./commands/db-pull.ts";
+import { runDbReset } from "./commands/db-reset.ts";
+import { runDbSeed } from "./commands/db-seed.ts";
+import { runDbExecute } from "./commands/db-execute.ts";
+import { runMigrateGenerate } from "./commands/migrate-generate.ts";
+import { runMigrateApply } from "./commands/migrate-apply.ts";
+import { runMigrateStatus } from "./commands/migrate-status.ts";
+import { runMigrateResolve } from "./commands/migrate-resolve.ts";
+
+// ─── Command Router ───────────────────────────────────────────────
+
+const COMMANDS: Record<string, (params: { config: VibeOrmConfig; flags: Record<string, string> }) => Promise<void>> = {
+  "generate": runGenerate,
+  "db push": runDbPush,
+  "db pull": runDbPull,
+  "db reset": runDbReset,
+  "db seed": runDbSeed,
+  "db execute": runDbExecute,
+  "migrate generate": runMigrateGenerate,
+  "migrate apply": runMigrateApply,
+  "migrate status": runMigrateStatus,
+  "migrate resolve": runMigrateResolve,
+};
+
+function printHelp(): void {
+  console.log("VibeORM CLI");
+  console.log("");
+  console.log("Usage: vibeorm <command> [options]");
+  console.log("");
+  console.log("Commands:");
+  console.log("  generate                        Parse .prisma schema and generate TypeScript client");
+  console.log("  db push [--force] [--accept-data-loss] [--dry-run]   Push schema directly to database (prototyping)");
+  console.log("  db pull [--print]               Introspect database and generate .prisma schema");
+  console.log("  db reset [--force] [--skip-seed] Drop all tables, re-apply migrations, and seed");
+  console.log("  db seed                         Run the configured seed script");
+  console.log("  db execute --file <path>        Execute a raw .sql file against the database");
+  console.log("  migrate generate [--name <n>] [--dry-run]   Generate a new migration from schema changes");
+  console.log("  migrate apply [--dry-run]       Apply all pending migrations");
+  console.log("  migrate status                  Show which migrations are applied/pending");
+  console.log("  migrate resolve --applied <name> | --rolled-back <name>   Repair migration state");
+  console.log("");
+  console.log("Options:");
+  console.log("  --schema <path>      Path to .prisma schema file");
+  console.log("  --output <path>      Path to generated client output directory");
+  console.log("  --migrations <path>  Path to migrations directory");
+  console.log("  --seed <path>        Path to seed script");
+  console.log("  --url <url>          Database connection URL");
+  console.log("  --help               Show this help message");
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+
+  // Determine command: try two-word commands first, then single-word
+  let command: string | undefined;
+  let flagArgs: string[];
+
+  const twoWord = `${args[0]} ${args[1]}`;
+  if (COMMANDS[twoWord]) {
+    command = twoWord;
+    flagArgs = args.slice(2);
+  } else if (COMMANDS[args[0]!]) {
+    command = args[0]!;
+    flagArgs = args.slice(1);
+  } else {
+    console.error(`Unknown command: ${args[0]}${args[1] ? " " + args[1] : ""}`);
+    console.error("");
+    printHelp();
+    process.exit(1);
+  }
+
+  const flags = parseFlags({ args: flagArgs });
+  const config = await resolveConfig({ flags });
+
+  const handler = COMMANDS[command]!;
+  await handler({ config, flags });
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err.message ?? err);
+  process.exit(1);
+});

package/src/schema-loader.ts

@@ -0,0 +1,50 @@
+/**
+ * Schema Loader — supports both single .prisma files and directories
+ * containing multiple .prisma files.
+ *
+ * If the path is a file, reads it directly.
+ * If the path is a directory, reads all *.prisma files within it
+ * (sorted alphabetically) and concatenates them.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+
+export function loadSchemaSource(params: { schemaPath: string }): string {
+  const { schemaPath } = params;
+
+  if (!existsSync(schemaPath)) {
+    console.error(`Error: Schema path not found at ${schemaPath}`);
+    console.error("Create a schema.prisma file or specify --schema <path>");
+    process.exit(1);
+  }
+
+  const stat = statSync(schemaPath);
+
+  if (stat.isFile()) {
+    return readFileSync(schemaPath, "utf-8");
+  }
+
+  if (stat.isDirectory()) {
+    const files = readdirSync(schemaPath)
+      .filter((f: string) => f.endsWith(".prisma"))
+      .sort();
+
+    if (files.length === 0) {
+      console.error(`Error: No .prisma files found in ${schemaPath}`);
+      process.exit(1);
+    }
+
+    const sources: string[] = [];
+    for (const file of files) {
+      const filePath = join(schemaPath, file);
+      sources.push(`// --- ${file} ---\n` + readFileSync(filePath, "utf-8"));
+    }
+
+    console.log(`  Loaded ${files.length} schema files from ${schemaPath}`);
+    return sources.join("\n\n");
+  }
+
+  console.error(`Error: ${schemaPath} is neither a file nor a directory`);
+  process.exit(1);
+}