@dooor-ai/cortexdb 0.6.1 → 0.6.3

package/dist/schema-cli/index.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -122,13 +155,18 @@ function printUsage() {
         `Usage:\n` +
         `  ${scriptName} schema diff [--dir path]\n` +
         `  ${scriptName} schema apply [--dir path] [--no-generate-types] [--out path]\n` +
+        `  ${scriptName} schema validate [--dir path]\n` +
         `  ${scriptName} schema generate-types --out src/generated/cortex-schema.ts [--dir path]\n` +
+        `  ${scriptName} migrate status\n` +
+        `  ${scriptName} migrate rollback [--steps N]\n` +
+        `  ${scriptName} db reset [--force]\n` +
+        `  ${scriptName} db pull [--format yaml|ts]\n` +
         `\nEnvironment variables:\n` +
-        `  DOOOR_CONFIG                Caminho para o config YAML (default ./dooor/config.yaml)\n` +
+        `  DOOOR_CONFIG                Path to config YAML (default ./dooor/config.yaml)\n` +
         `  CORTEXDB_CONNECTION         Full connection string (cortexdb://key@host:port)\n` +
         `  CORTEXDB_BASE_URL           Base URL (default http://localhost:8000)\n` +
         `  CORTEXDB_API_KEY            API key (required if no connection string)\n` +
-        `  CORTEXDB_SCHEMA_DIR         Override manual do diretório de schemas\n`);
+        `  CORTEXDB_SCHEMA_DIR         Override schema directory\n`);
 }
 function parseArgs(argv) {
     const opts = {};
@@ -200,7 +238,7 @@ function loadYamlFiles(schemaDir) {
     }
     const files = node_fs_1.default.readdirSync(schemaDir).filter((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
     if (files.length === 0) {
-        throw new Error(`No YAML schema files found in ${schemaDir}`);
+        return { version: 1, collections: [] }; // Return empty instead of throwing
     }
     const collections = [];
     for (const file of files) {
@@ -225,6 +263,89 @@ function loadYamlFiles(schemaDir) {
         collections,
     };
 }
+/**
+ * Load TypeScript schemas using decorators (@Collection, @Field)
+ */
+function loadTypeScriptFiles(schemaDir) {
+    try {
+        // Import the loader dynamically to avoid breaking if deps not installed
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const loaderModule = require("../schema-decorators/loader");
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const validatorModule = require("../schema-decorators/validator");
+        const collections = loaderModule.loadTypeScriptSchemasSync(schemaDir);
+        // Validate schemas
+        const validationResult = validatorModule.validateSchema(collections);
+        // Show warnings
+        if (validationResult.warnings.length > 0) {
+            console.log(validatorModule.formatValidationErrors({
+                valid: true,
+                errors: [],
+                warnings: validationResult.warnings
+            }));
+        }
+        // Fail on errors
+        if (!validationResult.valid) {
+            console.error(validatorModule.formatValidationErrors(validationResult));
+            throw new Error(`Schema validation failed with ${validationResult.errors.length} error(s)`);
+        }
+        // Convert LoadedCollection[] to DSLCollection[]
+        return {
+            version: 1,
+            collections: collections.map((col) => ({
+                name: col.name,
+                description: col.description,
+                database: col.database,
+                config: col.config,
+                fields: col.fields.map((field) => ({
+                    name: field.name,
+                    type: field.type,
+                    description: field.description,
+                    required: field.required,
+                    indexed: field.indexed,
+                    unique: field.unique,
+                    filterable: field.filterable,
+                    vectorize: field.vectorize,
+                    default: field.default,
+                    values: field.values,
+                    store_in: field.store_in,
+                    extract_config: field.extract_config,
+                    schema: field.schema,
+                })),
+            })),
+        };
+    }
+    catch (error) {
+        // If ts-node or decorators not available, silently return empty
+        if (error.code === "MODULE_NOT_FOUND" || error.message?.includes("Cannot find module")) {
+            return { version: 1, collections: [] };
+        }
+        throw error;
+    }
+}
+/**
+ * Load schemas from both YAML and TypeScript sources
+ */
+function loadAllSchemas(schemaDir) {
+    const yamlSchema = loadYamlFiles(schemaDir);
+    const tsSchema = loadTypeScriptFiles(schemaDir);
+    const allCollections = [...yamlSchema.collections, ...tsSchema.collections];
+    if (allCollections.length === 0) {
+        throw new Error(`No schema files found in ${schemaDir}. Create .yml, .yaml files, or .ts files with @Collection decorators.`);
+    }
+    // Check for duplicate collection names
+    const names = new Set();
+    for (const collection of allCollections) {
+        if (names.has(collection.name)) {
+            throw new Error(`Duplicate collection name '${collection.name}' found in schemas (check both YAML and TypeScript files)`);
+        }
+        names.add(collection.name);
+    }
+    return {
+        version: 1,
+        collections: allCollections,
+    };
+}
 function validateCollection(collection) {
     if (!collection.name || typeof collection.name !== "string") {
         throw new Error(`Collection is missing a valid name`);
@@ -417,7 +538,10 @@ async function resolveEmbeddingProviders(collections, client) {
     });
 }
 async function fetchCurrentCollections(client, desired) {
-    return await client.collections.list();
+    const current = await client.collections.list();
+    console.log('\n🔍 DEBUG: Current collections in database:', current.map(c => c.name).join(', ') || '(none)');
+    console.log('🔍 DEBUG: Desired collections:', desired.map(c => c.name).join(', '));
+    return current;
 }
 function buildEmbeddingProviderIndex(providers) {
     const index = new Map();
@@ -442,7 +566,7 @@ function buildEmbeddingProviderIndex(providers) {
     return index;
 }
 async function commandDiff(schemaDir) {
-    const desiredSchema = loadYamlFiles(schemaDir);
+    const desiredSchema = loadAllSchemas(schemaDir);
     const client = getClient();
     desiredSchema.collections.forEach(validateCollection);
     const currentCollections = await fetchCurrentCollections(client, desiredSchema.collections);
@@ -473,7 +597,7 @@ async function commandDiff(schemaDir) {
     return diff.update.length > 0 ? 1 : 0;
 }
 async function commandApply(schemaDir, migrationName, createOnly) {
-    const desiredSchema = loadYamlFiles(schemaDir);
+    const desiredSchema = loadAllSchemas(schemaDir);
     const client = getClient();
     desiredSchema.collections.forEach(validateCollection);
     const currentCollections = await fetchCurrentCollections(client, desiredSchema.collections);
@@ -492,8 +616,11 @@ async function commandApply(schemaDir, migrationName, createOnly) {
     // Process CREATE operations
     for (const collection of diff.create) {
         console.log(`\n📋 Generating migration for new collection: ${collection.name}`);
+        // Use collection database or default from connection string
+        const database = collection.database || client.getDefaultDatabase();
+        console.log(`🔍 DEBUG: Collection database:`, database || '(default)');
         const yamlContent = buildYamlForCollection(collection);
-        const migration = await generateMigration(client, yamlContent, migrationName, collection.database);
+        const migration = await generateMigration(client, yamlContent, migrationName, database);
         if (migration) {
             const { version, name, up_sql, down_sql, warnings } = migration;
             // Save migration files
@@ -510,7 +637,7 @@ async function commandApply(schemaDir, migrationName, createOnly) {
             if (!createOnly) {
                 // Apply migration
                 console.log(`  🚀 Applying migration...`);
-                await applyMigration(client, version, `${version}_${name}.sql`, up_sql);
+                await applyMigration(client, version, `${version}_${name}.sql`, up_sql, database, yamlContent);
                 console.log(`  ✓ Migration applied successfully`);
                 appliedMigrations.push({ version, name, collection: collection.name });
             }
@@ -519,8 +646,10 @@ async function commandApply(schemaDir, migrationName, createOnly) {
     // Process UPDATE operations
     for (const entry of diff.update) {
         console.log(`\n📋 Generating migration for updated collection: ${entry.desired.name}`);
+        // Use collection database or default from connection string
+        const database = entry.desired.database || client.getDefaultDatabase();
         const yamlContent = buildYamlForCollection(entry.desired);
-        const migration = await generateMigration(client, yamlContent, migrationName, entry.desired.database);
+        const migration = await generateMigration(client, yamlContent, migrationName, database);
         if (migration) {
             const { version, name, up_sql, down_sql, warnings } = migration;
             // Save migration files
@@ -537,7 +666,7 @@ async function commandApply(schemaDir, migrationName, createOnly) {
             if (!createOnly) {
                 // Apply migration
                 console.log(`  🚀 Applying migration...`);
-                await applyMigration(client, version, `${version}_${name}.sql`, up_sql);
+                await applyMigration(client, version, `${version}_${name}.sql`, up_sql, database, yamlContent);
                 console.log(`  ✓ Migration applied successfully`);
                 appliedMigrations.push({ version, name, collection: entry.desired.name });
             }
@@ -566,18 +695,30 @@ function buildYamlForCollection(collection) {
     if (collection.config) {
         yamlObj.config = collection.config;
     }
-    return require('yaml').stringify(yamlObj);
+    if (collection.database) {
+        yamlObj.database = collection.database;
+    }
+    const yamlString = require('yaml').stringify(yamlObj);
+    // Debug: log the YAML being sent
+    console.log('\n🔍 DEBUG: YAML being sent to backend:');
+    console.log('---');
+    console.log(yamlString);
+    console.log('---\n');
+    return yamlString;
 }
 async function generateMigration(client, yamlContent, name, database) {
     try {
+        console.log('🔍 DEBUG: Calling /migrations/generate with database:', database || '(default)');
         const response = await client.http.post('/migrations/generate', {
             yaml_content: yamlContent,
             name,
             database,
         });
+        console.log('🔍 DEBUG: Migration generated successfully');
         return response;
     }
     catch (error) {
+        console.log('🔍 DEBUG: Generate migration error:', error.response?.status, error.response?.data?.detail || error.message);
         if (error.response?.status === 400 && error.response?.data?.detail?.includes('No schema changes')) {
             // No changes detected - this is ok
             return null;
@@ -585,7 +726,7 @@ async function generateMigration(client, yamlContent, name, database) {
         throw error;
     }
 }
-async function applyMigration(client, version, filename, upSql) {
+async function applyMigration(client, version, filename, upSql, database, yamlSchema) {
     const crypto = require('crypto');
     const checksum = crypto.createHash('sha256').update(upSql).digest('hex');
     await client.http.post('/migrations/apply', {
@@ -593,8 +734,398 @@ async function applyMigration(client, version, filename, upSql) {
         filename,
         up_sql: upSql,
         checksum,
+        database,
+        yaml_schema: yamlSchema,
     });
 }
+async function commandDbReset(force = false) {
+    const client = getClient();
+    const migrationsDir = node_path_1.default.resolve(node_process_1.default.cwd(), "dooor", "migrations");
+    // Check if migrations directory exists
+    if (!node_fs_1.default.existsSync(migrationsDir)) {
+        console.error("✖ No migrations directory found at dooor/migrations/");
+        console.error("  Run 'dooor schema apply' first to generate migrations.");
+        return 1;
+    }
+    // Read all migration files (only UP migrations, not .down.sql)
+    const migrationFiles = node_fs_1.default.readdirSync(migrationsDir)
+        .filter((file) => file.endsWith(".sql") && !file.endsWith(".down.sql"))
+        .sort();
+    if (migrationFiles.length === 0) {
+        console.error("✖ No migration files found in dooor/migrations/");
+        console.error("  Run 'dooor schema apply' first to generate migrations.");
+        return 1;
+    }
+    // Check current database state before warning
+    console.log("\n🔍 Checking database state...\n");
+    let tableInfo = [];
+    try {
+        const database = client.getDefaultDatabase();
+        const statusResponse = await client.http.get(`/migrations/status?database=${database || ""}`);
+        tableInfo = (statusResponse.tables || []).map((t) => ({ name: t.name, rows: t.row_count }));
+    }
+    catch {
+        // If status endpoint doesn't exist, continue without table info
+    }
+    // Display warning with red styling
+    const chalk = await Promise.resolve().then(() => __importStar(require("chalk"))).then(m => m.default);
+    console.log(chalk.bgRed.white.bold(" ⚠️  DESTRUCTIVE OPERATION "));
+    console.log("");
+    console.log(chalk.red.bold("This will completely reset the database!"));
+    console.log("");
+    if (tableInfo.length > 0) {
+        const totalRows = tableInfo.reduce((sum, t) => sum + t.rows, 0);
+        console.log(chalk.red(`  📊 ${tableInfo.length} table(s) will be dropped:`));
+        tableInfo.forEach((t) => {
+            const rowText = t.rows > 0 ? chalk.yellow(`(${t.rows} rows)`) : chalk.gray("(empty)");
+            console.log(chalk.red(`     • ${t.name} ${rowText}`));
+        });
+        console.log("");
+        if (totalRows > 0) {
+            console.log(chalk.red.bold(`  💀 ${totalRows} total row(s) will be PERMANENTLY DELETED`));
+            console.log("");
+        }
+    }
+    else {
+        console.log(chalk.red("  • All user tables will be dropped"));
+        console.log(chalk.red("  • All data will be permanently lost"));
+        console.log("");
+    }
+    console.log(chalk.white(`  📋 ${migrationFiles.length} migration(s) will be re-applied`));
+    console.log("");
+    // Prompt for confirmation unless --force
+    if (!force) {
+        const readline = await Promise.resolve().then(() => __importStar(require("readline")));
+        const rl = readline.createInterface({
+            input: node_process_1.default.stdin,
+            output: node_process_1.default.stdout,
+        });
+        console.log(chalk.yellow.bold("This action cannot be undone."));
+        console.log("");
+        const answer = await new Promise((resolve) => {
+            rl.question(chalk.red.bold("Type 'yes' to confirm reset: "), (ans) => {
+                rl.close();
+                resolve(ans);
+            });
+        });
+        if (answer.toLowerCase() !== "yes") {
+            console.log("\n✖ Reset cancelled.");
+            return 1;
+        }
+    }
+    console.log("\n🔄 Resetting database...\n");
+    // Load all migrations
+    const crypto = require("crypto");
+    const migrations = [];
+    for (const filename of migrationFiles) {
+        const filePath = node_path_1.default.join(migrationsDir, filename);
+        const upSql = node_fs_1.default.readFileSync(filePath, "utf-8");
+        const checksum = crypto.createHash("sha256").update(upSql).digest("hex");
+        // Extract version from filename (e.g., 20250108_120000_123456_create_users.sql -> 20250108_120000_123456)
+        const name = filename.replace(".sql", "");
+        const parts = name.split("_");
+        let version = name;
+        if (parts.length >= 3 && parts[0].match(/^\d+$/) && parts[1].match(/^\d+$/)) {
+            // Format: YYYYMMDD_HHMMSS_microseconds_name
+            version = `${parts[0]}_${parts[1]}_${parts[2]}`;
+        }
+        else if (parts.length >= 2 && parts[0].match(/^\d+$/) && parts[1].match(/^\d+$/)) {
+            // Format: YYYYMMDD_HHMMSS_name
+            version = `${parts[0]}_${parts[1]}`;
+        }
+        migrations.push({
+            version,
+            filename,
+            up_sql: upSql,
+            checksum,
+        });
+    }
+    try {
+        const database = client.getDefaultDatabase();
+        // Cast to any to access private http property (same pattern as generateMigration/applyMigration)
+        const response = await client.http.post("/migrations/reset", {
+            database,
+            migrations,
+        });
+        // Display results
+        if (response.dropped_tables && response.dropped_tables.length > 0) {
+            console.log(`✓ Dropped ${response.dropped_tables.length} table(s):`);
+            response.dropped_tables.forEach((table) => {
+                console.log(`    - ${table}`);
+            });
+        }
+        else {
+            console.log("✓ No user tables to drop");
+        }
+        console.log("");
+        if (response.applied_migrations && response.applied_migrations.length > 0) {
+            console.log(`✓ Applied ${response.applied_migrations.length} migration(s):`);
+            response.applied_migrations.forEach((version) => {
+                console.log(`    - ${version}`);
+            });
+        }
+        else {
+            console.log("✓ No migrations to apply");
+        }
+        if (response.warnings && response.warnings.length > 0) {
+            console.log("\n⚠️  Warnings:");
+            response.warnings.forEach((warning) => {
+                console.log(`    - ${warning}`);
+            });
+        }
+        console.log("\n✔ Database reset completed successfully!");
+        return 0;
+    }
+    catch (error) {
+        const message = error.response?.data?.detail || error.message;
+        console.error(`\n✖ Reset failed: ${message}`);
+        return 1;
+    }
+}
+async function commandMigrateStatus() {
+    const client = getClient();
+    const migrationsDir = node_path_1.default.resolve(node_process_1.default.cwd(), "dooor", "migrations");
+    const chalk = await Promise.resolve().then(() => __importStar(require("chalk"))).then(m => m.default);
+    console.log(chalk.bold("\n📋 Migration Status\n"));
+    // Fetch applied migrations from the server
+    let appliedMigrations = [];
+    try {
+        const database = client.getDefaultDatabase();
+        const queryParam = database ? `?database=${database}` : '';
+        appliedMigrations = await client.http.get(`/migrations/history${queryParam}`);
+    }
+    catch (error) {
+        // If endpoint fails, assume no migrations applied
+        if (error.response?.status !== 404) {
+            console.warn(chalk.yellow(`  ⚠ Could not fetch migration history: ${error.message}`));
+        }
+    }
+    // Read local migration files
+    let localMigrations = [];
+    if (node_fs_1.default.existsSync(migrationsDir)) {
+        localMigrations = node_fs_1.default.readdirSync(migrationsDir)
+            .filter((file) => file.endsWith(".sql") && !file.endsWith(".down.sql"))
+            .sort();
+    }
+    // Build map of applied migrations by version
+    const appliedMap = new Map();
+    appliedMigrations.forEach((m) => {
+        appliedMap.set(m.version, m);
+    });
+    // Extract versions from local files
+    const localVersions = new Map();
+    localMigrations.forEach((filename) => {
+        const name = filename.replace(".sql", "");
+        const parts = name.split("_");
+        let version = name;
+        if (parts.length >= 3 && parts[0].match(/^\d+$/) && parts[1].match(/^\d+$/)) {
+            version = `${parts[0]}_${parts[1]}_${parts[2]}`;
+        }
+        else if (parts.length >= 2 && parts[0].match(/^\d+$/) && parts[1].match(/^\d+$/)) {
+            version = `${parts[0]}_${parts[1]}`;
+        }
+        localVersions.set(version, filename);
+    });
+    // Table header
+    const colVersion = 28;
+    const colName = 40;
+    const colStatus = 12;
+    const colDate = 20;
+    const header = chalk.gray("─".repeat(colVersion + colName + colStatus + colDate + 9)) + "\n" +
+        chalk.bold(" " + "VERSION".padEnd(colVersion) + " │ " +
+            "NAME".padEnd(colName) + " │ " +
+            "STATUS".padEnd(colStatus) + " │ " +
+            "APPLIED AT") + "\n" +
+        chalk.gray("─".repeat(colVersion + colName + colStatus + colDate + 9));
+    console.log(header);
+    // Show applied migrations
+    if (appliedMigrations.length === 0 && localMigrations.length === 0) {
+        console.log(chalk.gray("\n  No migrations found.\n"));
+        return 0;
+    }
+    // Combine and sort all migrations
+    const allVersions = new Set([
+        ...appliedMap.keys(),
+        ...localVersions.keys()
+    ]);
+    const sortedVersions = Array.from(allVersions).sort();
+    for (const version of sortedVersions) {
+        const applied = appliedMap.get(version);
+        const localFile = localVersions.get(version);
+        let displayName = "";
+        let status = "";
+        let statusColor = chalk.gray;
+        let dateStr = "";
+        if (applied) {
+            // Extract name from filename
+            const filenameWithoutExt = applied.filename.replace(".sql", "");
+            const versionPrefix = version + "_";
+            displayName = filenameWithoutExt.startsWith(versionPrefix)
+                ? filenameWithoutExt.slice(versionPrefix.length)
+                : filenameWithoutExt;
+            if (applied.status === "applied") {
+                status = "applied";
+                statusColor = chalk.green;
+            }
+            else if (applied.status === "rolled_back") {
+                status = "rolled_back";
+                statusColor = chalk.yellow;
+                if (applied.rolled_back_at) {
+                    dateStr = formatDate(applied.rolled_back_at);
+                }
+            }
+            else {
+                status = applied.status;
+                statusColor = chalk.gray;
+            }
+            if (applied.applied_at && applied.status !== "rolled_back") {
+                dateStr = formatDate(applied.applied_at);
+            }
+        }
+        else if (localFile) {
+            // Pending migration (exists locally but not applied)
+            const filenameWithoutExt = localFile.replace(".sql", "");
+            const versionPrefix = version + "_";
+            displayName = filenameWithoutExt.startsWith(versionPrefix)
+                ? filenameWithoutExt.slice(versionPrefix.length)
+                : filenameWithoutExt;
+            status = "pending";
+            statusColor = chalk.blue;
+            dateStr = "-";
+        }
+        // Truncate name if too long
+        if (displayName.length > colName) {
+            displayName = displayName.slice(0, colName - 3) + "...";
+        }
+        const row = " " + chalk.white(version.padEnd(colVersion)) + " │ " +
+            chalk.white(displayName.padEnd(colName)) + " │ " +
+            statusColor(status.padEnd(colStatus)) + " │ " +
+            chalk.gray(dateStr);
+        console.log(row);
+    }
+    console.log(chalk.gray("─".repeat(colVersion + colName + colStatus + colDate + 9)));
+    // Summary
+    const appliedCount = appliedMigrations.filter(m => m.status === "applied").length;
+    const rolledBackCount = appliedMigrations.filter(m => m.status === "rolled_back").length;
+    const pendingCount = Array.from(localVersions.keys()).filter(v => !appliedMap.has(v)).length;
+    console.log("");
+    console.log(chalk.bold("Summary:"));
+    console.log(chalk.green(`  ✓ Applied: ${appliedCount}`));
+    if (rolledBackCount > 0) {
+        console.log(chalk.yellow(`  ↩ Rolled back: ${rolledBackCount}`));
+    }
+    if (pendingCount > 0) {
+        console.log(chalk.blue(`  ⏳ Pending: ${pendingCount}`));
+    }
+    console.log("");
+    return 0;
+}
+function formatDate(isoString) {
+    try {
+        const date = new Date(isoString);
+        return date.toLocaleString("en-US", {
+            month: "short",
+            day: "2-digit",
+            year: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false
+        });
+    }
+    catch {
+        return isoString;
+    }
+}
+async function commandMigrateRollback(steps = 1) {
+    const client = getClient();
+    const migrationsDir = node_path_1.default.resolve(node_process_1.default.cwd(), "dooor", "migrations");
+    const chalk = await Promise.resolve().then(() => __importStar(require("chalk"))).then(m => m.default);
+    console.log(chalk.bold("\n↩️  Migration Rollback\n"));
+    // Check if migrations directory exists
+    if (!node_fs_1.default.existsSync(migrationsDir)) {
+        console.error(chalk.red("✖ No migrations directory found at dooor/migrations/"));
+        return 1;
+    }
+    // Fetch applied migrations from the server
+    let appliedMigrations = [];
+    try {
+        const database = client.getDefaultDatabase();
+        const queryParam = database ? `?database=${database}` : '';
+        appliedMigrations = await client.http.get(`/migrations/history${queryParam}`);
+    }
+    catch (error) {
+        console.error(chalk.red(`✖ Could not fetch migration history: ${error.message}`));
+        return 1;
+    }
+    // Filter only applied migrations and sort by version descending
+    const appliedOnly = appliedMigrations
+        .filter(m => m.status === "applied")
+        .sort((a, b) => b.version.localeCompare(a.version));
+    if (appliedOnly.length === 0) {
+        console.log(chalk.yellow("No migrations to rollback."));
+        return 0;
+    }
+    // Get the migrations to rollback (last N applied)
+    const toRollback = appliedOnly.slice(0, steps);
+    console.log(chalk.white(`Rolling back ${toRollback.length} migration(s):\n`));
+    let rolledBack = 0;
+    let failed = 0;
+    for (const migration of toRollback) {
+        const { version, filename } = migration;
+        // Find the .down.sql file
+        const downFilename = filename.replace(".sql", ".down.sql");
+        const downFilePath = node_path_1.default.join(migrationsDir, downFilename);
+        if (!node_fs_1.default.existsSync(downFilePath)) {
+            console.log(chalk.red(`  ✖ ${version} - Down file not found: ${downFilename}`));
+            failed++;
+            continue;
+        }
+        // Read the down SQL
+        const downSql = node_fs_1.default.readFileSync(downFilePath, "utf-8");
+        // Call the rollback endpoint
+        try {
+            const database = client.getDefaultDatabase();
+            await client.http.post('/migrations/rollback', {
+                version,
+                down_sql: downSql,
+                database,
+            });
+            console.log(chalk.green(`  ✓ ${version} - ${extractMigrationName(filename)}`));
+            rolledBack++;
+        }
+        catch (error) {
+            const message = error.response?.data?.detail || error.message;
+            console.log(chalk.red(`  ✖ ${version} - Failed: ${message}`));
+            failed++;
+            // Stop on first failure
+            break;
+        }
+    }
+    console.log("");
+    if (rolledBack > 0) {
+        console.log(chalk.green(`✔ Rolled back ${rolledBack} migration(s) successfully.`));
+    }
+    if (failed > 0) {
+        console.log(chalk.red(`✖ ${failed} migration(s) failed to rollback.`));
+        return 1;
+    }
+    return 0;
+}
+function extractMigrationName(filename) {
+    // Remove .sql extension
+    const name = filename.replace(".sql", "");
+    // Split by underscore and skip version parts (YYYYMMDD_HHMMSS_microseconds)
+    const parts = name.split("_");
+    if (parts.length >= 4 && parts[0].match(/^\d+$/) && parts[1].match(/^\d+$/)) {
+        // Format: YYYYMMDD_HHMMSS_microseconds_name
+        return parts.slice(3).join("_");
+    }
+    else if (parts.length >= 3 && parts[0].match(/^\d+$/) && parts[1].match(/^\d+$/)) {
+        // Format: YYYYMMDD_HHMMSS_name
+        return parts.slice(2).join("_");
+    }
+    return name;
+}
 function mapFieldTypeToTs(field) {
     switch (field.type) {
         case __1.FieldType.STRING:
@@ -732,7 +1263,7 @@ async function commandGenerateTypes(schemaDir, outPath) {
     if (!resolvedOut) {
         resolvedOut = "dooor/generated/cortex-schema.ts";
     }
-    const desiredSchema = loadYamlFiles(schemaDir);
+    const desiredSchema = loadAllSchemas(schemaDir);
     desiredSchema.collections.forEach(validateCollection);
     const absoluteOut = node_path_1.default.resolve(node_process_1.default.cwd(), resolvedOut);
     const content = buildTypesContent(schemaDir, desiredSchema);
@@ -742,6 +1273,271 @@ async function commandGenerateTypes(schemaDir, outPath) {
     console.log(`✔ Types generated at ${absoluteOut}`);
     return 0;
 }
+async function commandSchemaValidate(schemaDir) {
+    const chalk = await Promise.resolve().then(() => __importStar(require("chalk"))).then(m => m.default);
+    console.log(chalk.bold("\n🔍 Schema Validation\n"));
+    try {
+        // Load all schemas (YAML and TS)
+        const desiredSchema = loadAllSchemas(schemaDir);
+        if (desiredSchema.collections.length === 0) {
+            console.log(chalk.yellow("No schemas found to validate."));
+            return 0;
+        }
+        console.log(chalk.white(`Found ${desiredSchema.collections.length} collection(s) to validate:\n`));
+        // Run basic validation for each collection
+        let hasErrors = false;
+        const allWarnings = [];
+        for (const collection of desiredSchema.collections) {
+            try {
+                validateCollection(collection);
+                console.log(chalk.green(`  ✓ ${collection.name}`));
+            }
+            catch (error) {
+                console.log(chalk.red(`  ✖ ${collection.name}: ${error.message}`));
+                hasErrors = true;
+            }
+        }
+        // Try to run advanced validation from the validator module
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const validatorModule = require("../schema-decorators/validator");
+            // Convert DSLCollection[] to the format expected by validateSchema
+            const collectionsForValidation = desiredSchema.collections.map((col) => ({
+                name: col.name,
+                description: col.description,
+                database: col.database,
+                config: col.config,
+                fields: col.fields.map((field) => ({
+                    name: field.name,
+                    type: field.type,
+                    description: field.description,
+                    required: field.required,
+                    indexed: field.indexed,
+                    unique: field.unique,
+                    filterable: field.filterable,
+                    vectorize: field.vectorize,
+                    default: field.default,
+                    values: field.values,
+                    store_in: field.store_in,
+                    extract_config: field.extract_config,
+                    schema: field.schema,
+                })),
+            }));
+            const validationResult = validatorModule.validateSchema(collectionsForValidation);
+            // Collect warnings
+            if (validationResult.warnings && validationResult.warnings.length > 0) {
+                allWarnings.push(...validationResult.warnings);
+            }
+            // Check for errors
+            if (!validationResult.valid) {
+                hasErrors = true;
+                console.log("");
+                console.log(validatorModule.formatValidationErrors(validationResult));
+            }
+        }
+        catch (validatorError) {
+            // Validator module not available, skip advanced validation
+            if (validatorError.code !== "MODULE_NOT_FOUND") {
+                console.warn(chalk.yellow(`\n  ⚠ Advanced validation skipped: ${validatorError.message}`));
+            }
+        }
+        console.log("");
+        // Show warnings
+        if (allWarnings.length > 0) {
+            console.log(chalk.yellow("Warnings:"));
+            allWarnings.forEach((warning) => {
+                console.log(chalk.yellow(`  ⚠ ${warning}`));
+            });
+            console.log("");
+        }
+        // Summary
+        if (hasErrors) {
+            console.log(chalk.red("✖ Schema validation failed with errors."));
+            return 1;
+        }
+        console.log(chalk.green(`✔ All ${desiredSchema.collections.length} schema(s) are valid.`));
+        return 0;
+    }
+    catch (error) {
+        console.error(chalk.red(`✖ ${error.message}`));
+        return 1;
+    }
+}
+async function commandDbPull(format = "yaml") {
+    const client = getClient();
+    const chalk = await Promise.resolve().then(() => __importStar(require("chalk"))).then(m => m.default);
+    const outputDir = node_path_1.default.resolve(node_process_1.default.cwd(), "dooor", "schemas");
+    console.log(chalk.bold("\n📥 Database Introspection\n"));
+    try {
+        const database = client.getDefaultDatabase();
+        const queryParam = database ? `?database=${database}` : '';
+        const tables = await client.http.get(`/database/introspect${queryParam}`);
+        if (tables.length === 0) {
+            console.log(chalk.yellow("No user tables found in the database."));
+            return 0;
+        }
+        console.log(chalk.white(`Found ${tables.length} table(s):\n`));
+        // Ensure output directory exists
+        node_fs_1.default.mkdirSync(outputDir, { recursive: true });
+        const generatedFiles = [];
+        for (const table of tables) {
+            console.log(chalk.white(`  Processing ${table.name}...`));
+            if (format === "yaml") {
+                const yamlContent = generateYamlSchema(table);
+                const filePath = node_path_1.default.join(outputDir, `${table.name}.yaml`);
+                node_fs_1.default.writeFileSync(filePath, yamlContent, "utf-8");
+                generatedFiles.push(filePath);
+                console.log(chalk.green(`    ✓ Generated ${table.name}.yaml`));
+            }
+            else {
+                const tsContent = generateTsSchema(table);
+                const filePath = node_path_1.default.join(outputDir, `${table.name}.schema.ts`);
+                node_fs_1.default.writeFileSync(filePath, tsContent, "utf-8");
+                generatedFiles.push(filePath);
+                console.log(chalk.green(`    ✓ Generated ${table.name}.schema.ts`));
+            }
+        }
+        console.log("");
+        console.log(chalk.green(`✔ Generated ${generatedFiles.length} schema file(s) in ${outputDir}`));
+        return 0;
+    }
+    catch (error) {
+        const message = error.response?.data?.detail || error.message;
+        console.error(chalk.red(`✖ Introspection failed: ${message}`));
+        return 1;
+    }
+}
+function pgTypeToFieldType(pgType) {
+    const typeMap = {
+        // Text types
+        'text': 'text',
+        'varchar': 'string',
+        'character varying': 'string',
+        'char': 'string',
+        'character': 'string',
+        'name': 'string',
+        // Numeric types
+        'integer': 'int',
+        'int': 'int',
+        'int4': 'int',
+        'smallint': 'int',
+        'int2': 'int',
+        'bigint': 'int',
+        'int8': 'int',
+        'serial': 'int',
+        'bigserial': 'int',
+        'real': 'float',
+        'float4': 'float',
+        'double precision': 'float',
+        'float8': 'float',
+        'numeric': 'float',
+        'decimal': 'float',
+        // Boolean
+        'boolean': 'boolean',
+        'bool': 'boolean',
+        // Date/Time
+        'date': 'date',
+        'timestamp': 'datetime',
+        'timestamp without time zone': 'datetime',
+        'timestamp with time zone': 'datetime',
+        'timestamptz': 'datetime',
+        'time': 'string',
+        // JSON
+        'json': 'json',
+        'jsonb': 'json',
+        // UUID
+        'uuid': 'string',
+        // Arrays - simplified
+        'array': 'json',
+        // Binary
+        'bytea': 'file',
+    };
+    const normalized = pgType.toLowerCase().replace(/\(\d+\)/, '').trim();
+    return typeMap[normalized] || 'string';
+}
+function generateYamlSchema(table) {
+    const yaml = require('yaml');
+    const fields = table.columns
+        .filter(col => col.name !== 'id' && col.name !== 'created_at' && col.name !== 'updated_at')
+        .map(col => {
+        const field = {
+            name: col.name,
+            type: pgTypeToFieldType(col.type),
+        };
+        if (!col.nullable) {
+            field.required = true;
+        }
+        if (col.is_unique) {
+            field.unique = true;
+        }
+        if (col.is_primary) {
+            field.indexed = true;
+        }
+        return field;
+    });
+    const schema = {
+        version: 1,
+        collections: [
+            {
+                name: table.name,
+                fields,
+            },
+        ],
+    };
+    return yaml.stringify(schema);
+}
+function generateTsSchema(table) {
+    const pascalName = table.name
+        .split('_')
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    const lines = [];
+    lines.push(`import { Collection, Field } from '@dooor-ai/cortexdb';`);
+    lines.push('');
+    lines.push(`@Collection({`);
+    lines.push(`  name: '${table.name}',`);
+    lines.push(`})`);
+    lines.push(`export class ${pascalName}Schema {`);
+    for (const col of table.columns) {
+        // Skip common auto-generated columns
+        if (col.name === 'id' || col.name === 'created_at' || col.name === 'updated_at') {
+            continue;
+        }
+        const fieldType = pgTypeToFieldType(col.type);
+        const decoratorParts = [`type: '${fieldType}'`];
+        if (!col.nullable) {
+            decoratorParts.push('required: true');
+        }
+        if (col.is_unique) {
+            decoratorParts.push('unique: true');
+        }
+        if (col.is_primary) {
+            decoratorParts.push('indexed: true');
+        }
+        lines.push(`  @Field({ ${decoratorParts.join(', ')} })`);
+        lines.push(`  ${col.name}!: ${fieldTypeToTsType(fieldType)};`);
+        lines.push('');
+    }
+    lines.push('}');
+    lines.push('');
+    return lines.join('\n');
+}
+function fieldTypeToTsType(fieldType) {
+    const typeMap = {
+        'string': 'string',
+        'text': 'string',
+        'int': 'number',
+        'float': 'number',
+        'boolean': 'boolean',
+        'date': 'string',
+        'datetime': 'string',
+        'json': 'any',
+        'file': 'string',
+        'enum': 'string',
+        'array': 'any[]',
+    };
+    return typeMap[fieldType] || 'any';
+}
 async function main() {
     const argv = node_process_1.default.argv.slice(2);
     if (argv.length === 0) {
@@ -758,8 +1554,84 @@ async function main() {
         printUsage();
         node_process_1.default.exit(0);
     }
+    if (topic === "db") {
+        if (command === "reset") {
+            const options = parseArgs(rest);
+            const force = options.force === true;
+            try {
+                const exitCode = await commandDbReset(force);
+                node_process_1.default.exit(exitCode);
+            }
+            catch (error) {
+                console.error(`✖ ${error.message}`);
+                node_process_1.default.exit(1);
+            }
+        }
+        else if (command === "pull") {
+            const options = parseArgs(rest);
+            let format = "yaml";
+            if (typeof options.format === "string") {
+                const normalizedFormat = options.format.toLowerCase();
+                if (normalizedFormat !== "yaml" && normalizedFormat !== "ts") {
+                    console.error("✖ --format must be 'yaml' or 'ts'");
+                    node_process_1.default.exit(1);
+                }
+                format = normalizedFormat;
+            }
+            try {
+                const exitCode = await commandDbPull(format);
+                node_process_1.default.exit(exitCode);
+            }
+            catch (error) {
+                console.error(`✖ ${error.message}`);
+                node_process_1.default.exit(1);
+            }
+        }
+        else {
+            console.error(`Unknown db command '${command}'. Expected 'reset' or 'pull'.\n`);
+            printUsage();
+            node_process_1.default.exit(1);
+        }
+    }
+    if (topic === "migrate") {
+        if (command === "status") {
+            try {
+                const exitCode = await commandMigrateStatus();
+                node_process_1.default.exit(exitCode);
+            }
+            catch (error) {
+                console.error(`✖ ${error.message}`);
+                node_process_1.default.exit(1);
+            }
+        }
+        else if (command === "rollback") {
+            try {
+                const options = parseArgs(rest);
+                let steps = 1;
+                if (typeof options.steps === "string") {
+                    const parsed = parseInt(options.steps, 10);
+                    if (isNaN(parsed) || parsed < 1) {
+                        console.error("✖ --steps must be a positive integer");
+                        node_process_1.default.exit(1);
+                    }
+                    steps = parsed;
+                }
+                const exitCode = await commandMigrateRollback(steps);
+                node_process_1.default.exit(exitCode);
+            }
+            catch (error) {
+                console.error(`✖ ${error.message}`);
+                node_process_1.default.exit(1);
+            }
+        }
+        else {
+            console.error(`Unknown migrate command '${command}'. Expected 'status' or 'rollback'.\n`);
+            printUsage();
+            node_process_1.default.exit(1);
+        }
+    }
     if (topic !== "schema") {
-        console.error(`Unknown topic '${topic}'. Expected 'schema'.\n`);
+        console.error(`Unknown topic '${topic}'. Expected 'schema', 'migrate', or 'db'.\n`);
         printUsage();
         node_process_1.default.exit(1);
     }
@@ -784,6 +1656,9 @@ async function main() {
                 exitCode = typesResult !== 0 ? typesResult : exitCode;
             }
         }
+        else if (command === "validate") {
+            exitCode = await commandSchemaValidate(schemaDir);
+        }
         else if (command === "generate-types") {
             exitCode = await commandGenerateTypes(schemaDir, options.out);
         }