realitydb 1.4.3 → 1.5.0

package/dist/index.js

@@ -3476,83 +3476,10 @@ var {
   Help
 } = import_index.default;
 
-// ../../packages/config/dist/loadConfig.js
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
-
-// ../../packages/config/dist/defaults.js
-var DEFAULT_CONFIG = {
-  seed: {
-    defaultRecords: 5e3,
-    batchSize: 1e3,
-    environment: "dev"
-  },
-  export: {
-    defaultFormat: "json",
-    outputDir: "./.databox"
-  }
-};
-
-// ../../packages/config/dist/loadConfig.js
-var CONFIG_FILES = ["realitydb.config.json", "seedforge.config.json", "databox.config.json"];
-async function findConfigFile(basePath) {
-  for (const name of CONFIG_FILES) {
-    const fullPath = (0, import_node_path.resolve)(basePath, name);
-    try {
-      await (0, import_promises.access)(fullPath);
-      return fullPath;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-async function loadConfig(filePath) {
-  let resolvedPath;
-  if (filePath) {
-    resolvedPath = (0, import_node_path.resolve)(filePath);
-  } else {
-    const found = await findConfigFile(".");
-    if (!found) {
-      throw new Error(`[realitydb] Config file not found.
-Create a realitydb.config.json or specify a path with --config.`);
-    }
-    resolvedPath = found;
-  }
-  let raw;
-  try {
-    raw = await (0, import_promises.readFile)(resolvedPath, "utf-8");
-  } catch {
-    throw new Error(`[realitydb] Config file not found: ${resolvedPath}
-Create a realitydb.config.json or specify a path with --config.`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`[realitydb] Invalid JSON in config file: ${resolvedPath}`);
-  }
-  const config = parsed;
-  const database = config["database"];
-  if (!database || typeof database["connectionString"] !== "string") {
-    throw new Error("[realitydb] Config validation failed: database.connectionString is required.");
-  }
-  return {
-    database: {
-      client: "postgres",
-      connectionString: database["connectionString"]
-    },
-    seed: {
-      ...DEFAULT_CONFIG.seed,
-      ...config["seed"] ?? {}
-    },
-    template: config["template"],
-    export: {
-      ...DEFAULT_CONFIG.export,
-      ...config["export"] ?? {}
-    }
-  };
-}
+// src/commands/init.ts
+var import_node_readline = require("readline");
+var import_node_process = require("process");
+var import_node_fs7 = require("fs");
 
 // ../../packages/core/dist/planning/dependencyGraph.js
 function buildDependencyGraph(foreignKeys) {
@@ -4390,32 +4317,32 @@ function generateDataset(plan) {
 }
 
 // ../../packages/generators/dist/exporters/json.js
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
 async function exportToJson(dataset, outputDir) {
-  await (0, import_promises2.mkdir)(outputDir, { recursive: true });
+  await (0, import_promises.mkdir)(outputDir, { recursive: true });
   const files = [];
   for (const [tableName, table] of dataset.tables) {
-    const filePath = (0, import_node_path2.join)(outputDir, `${tableName}.json`);
+    const filePath = (0, import_node_path.join)(outputDir, `${tableName}.json`);
     const content = JSON.stringify(table.rows, null, 2);
-    await (0, import_promises2.writeFile)(filePath, content, "utf-8");
+    await (0, import_promises.writeFile)(filePath, content, "utf-8");
     files.push(filePath);
   }
   return files;
 }
 
 // ../../packages/generators/dist/exporters/csv.js
-var import_promises3 = require("fs/promises");
-var import_node_path3 = require("path");
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
 async function exportToCsv(dataset, outputDir) {
-  await (0, import_promises3.mkdir)(outputDir, { recursive: true });
+  await (0, import_promises2.mkdir)(outputDir, { recursive: true });
   const files = [];
   for (const [tableName, table] of dataset.tables) {
-    const filePath = (0, import_node_path3.join)(outputDir, `${tableName}.csv`);
+    const filePath = (0, import_node_path2.join)(outputDir, `${tableName}.csv`);
     const header = table.columns.map(escapeCsvField).join(",");
     const rows = table.rows.map((row) => table.columns.map((col) => escapeCsvField(String(row[col] ?? ""))).join(","));
     const content = [header, ...rows].join("\n");
-    await (0, import_promises3.writeFile)(filePath, content, "utf-8");
+    await (0, import_promises2.writeFile)(filePath, content, "utf-8");
     files.push(filePath);
   }
   return files;
@@ -4428,10 +4355,10 @@ function escapeCsvField(value) {
 }
 
 // ../../packages/generators/dist/exporters/sql.js
-var import_promises4 = require("fs/promises");
-var import_node_path4 = require("path");
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
 async function exportToSql(dataset, outputDir, tableOrder) {
-  await (0, import_promises4.mkdir)(outputDir, { recursive: true });
+  await (0, import_promises3.mkdir)(outputDir, { recursive: true });
   const lines = [];
   lines.push("-- Generated by DataBox");
   lines.push(`-- Seed: ${dataset.seed}`);
@@ -4448,8 +4375,8 @@ async function exportToSql(dataset, outputDir, tableOrder) {
     }
     lines.push("");
   }
-  const filePath = (0, import_node_path4.join)(outputDir, "seed.sql");
-  await (0, import_promises4.writeFile)(filePath, lines.join("\n"), "utf-8");
+  const filePath = (0, import_node_path3.join)(outputDir, "seed.sql");
+  await (0, import_promises3.writeFile)(filePath, lines.join("\n"), "utf-8");
   return [filePath];
 }
 function escapeSqlValue(value) {
@@ -5731,7 +5658,7 @@ function countRows2(dataset) {
 
 // ../../packages/generators/dist/scenarios/loadScenario.js
 var import_node_fs = require("fs");
-var import_node_path5 = require("path");
+var import_node_path4 = require("path");
 function scaffoldCustomScenario(name) {
   return {
     name,
@@ -5802,8 +5729,8 @@ function extractTablesFromModifications(modifications) {
 }
 
 // ../../packages/generators/dist/packExporter.js
-var import_promises5 = require("fs/promises");
-var import_node_path6 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_path5 = require("path");
 function exportRealityPack(dataset, plan, schema, options) {
   const name = options?.name ?? plan.config.templateName ?? "realitydb-pack";
   const packSchema = {
@@ -5851,14 +5778,14 @@ function exportRealityPack(dataset, plan, schema, options) {
 }
 async function saveRealityPack(pack, outputPath) {
   const filePath = outputPath.endsWith(".realitydb-pack.json") || outputPath.endsWith(".databox-pack.json") ? outputPath : `${outputPath}/${pack.metadata.name}.realitydb-pack.json`;
-  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(filePath), { recursive: true });
-  await (0, import_promises5.writeFile)(filePath, JSON.stringify(pack, null, 2), "utf-8");
+  await (0, import_promises4.mkdir)((0, import_node_path5.dirname)(filePath), { recursive: true });
+  await (0, import_promises4.writeFile)(filePath, JSON.stringify(pack, null, 2), "utf-8");
   return filePath;
 }
 async function loadRealityPack(filePath) {
   let raw;
   try {
-    raw = await (0, import_promises5.readFile)(filePath, "utf-8");
+    raw = await (0, import_promises4.readFile)(filePath, "utf-8");
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to read Reality Pack file: ${message}`);
@@ -6414,7 +6341,7 @@ function isIntLike(value) {
 }
 
 // ../../packages/generators/dist/writers/parquet.js
-var import_promises6 = require("fs/promises");
+var import_promises5 = require("fs/promises");
 async function appendParquetBatch(rows, filePath) {
   const { appendFile: appendFile3 } = await import("fs/promises");
   const lines = rows.map((row) => JSON.stringify(row)).join("\n") + "\n";
@@ -6422,14 +6349,14 @@ async function appendParquetBatch(rows, filePath) {
 }
 
 // ../../packages/generators/dist/writers/csv.js
-var import_promises7 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 async function writeCsvHeader(columns, filePath) {
   const header = columns.map(escapeCsvField2).join(",") + "\n";
-  await (0, import_promises7.writeFile)(filePath, header, "utf-8");
+  await (0, import_promises6.writeFile)(filePath, header, "utf-8");
 }
 async function appendCsvBatch(rows, columns, filePath) {
   const lines = rows.map((row) => columns.map((col) => escapeCsvField2(String(row[col] ?? ""))).join(",")).join("\n") + "\n";
-  await (0, import_promises7.appendFile)(filePath, lines, "utf-8");
+  await (0, import_promises6.appendFile)(filePath, lines, "utf-8");
 }
 function escapeCsvField2(value) {
   if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
@@ -6439,13 +6366,13 @@ function escapeCsvField2(value) {
 }
 
 // ../../packages/generators/dist/writers/json.js
-var import_promises8 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 async function writeJsonHeader(filePath) {
-  await (0, import_promises8.writeFile)(filePath, "", "utf-8");
+  await (0, import_promises7.writeFile)(filePath, "", "utf-8");
 }
 async function appendJsonBatch(rows, filePath) {
   const lines = rows.map((row) => JSON.stringify(row)).join("\n") + "\n";
-  await (0, import_promises8.appendFile)(filePath, lines, "utf-8");
+  await (0, import_promises7.appendFile)(filePath, lines, "utf-8");
 }
 
 // ../../packages/generators/dist/analyze/columnDetector.js
@@ -7309,13 +7236,13 @@ var CourseRegistry = class {
 
 // ../../packages/generators/dist/classroom/progressTracker.js
 var import_node_fs2 = require("fs");
-var import_node_path7 = require("path");
+var import_node_path6 = require("path");
 var import_node_os = require("os");
 function getProgressDir() {
-  return (0, import_node_path7.join)((0, import_node_os.homedir)(), ".realitydb");
+  return (0, import_node_path6.join)((0, import_node_os.homedir)(), ".realitydb");
 }
 function getProgressPath() {
-  return (0, import_node_path7.join)(getProgressDir(), "progress.json");
+  return (0, import_node_path6.join)(getProgressDir(), "progress.json");
 }
 function loadProgress() {
   const filePath = getProgressPath();
@@ -10304,7 +10231,7 @@ var VALID_STRATEGY_KINDS = [
 
 // ../../packages/templates/dist/loadTemplate.js
 var import_node_fs3 = require("fs");
-var import_node_path8 = require("path");
+var import_node_path7 = require("path");
 
 // ../../packages/templates/dist/validateTemplate.js
 function validateTemplateJSON(json) {
@@ -10388,7 +10315,7 @@ function assertValidTemplate(json) {
 
 // ../../packages/templates/dist/loadTemplate.js
 function loadTemplateFromJSON(filePath) {
-  const resolvedPath = (0, import_node_path8.resolve)(filePath);
+  const resolvedPath = (0, import_node_path7.resolve)(filePath);
   let raw;
   try {
     raw = (0, import_node_fs3.readFileSync)(resolvedPath, "utf-8");
@@ -10441,11 +10368,11 @@ function convertToDomainTemplate(json) {
 
 // ../../packages/templates/dist/userTemplates.js
 var import_node_os2 = require("os");
-var import_node_path9 = require("path");
+var import_node_path8 = require("path");
 var import_node_fs4 = require("fs");
 var USER_TEMPLATE_DIR_NAME = ".realitydb/templates";
 function getUserTemplateDir() {
-  return (0, import_node_path9.join)((0, import_node_os2.homedir)(), USER_TEMPLATE_DIR_NAME);
+  return (0, import_node_path8.join)((0, import_node_os2.homedir)(), USER_TEMPLATE_DIR_NAME);
 }
 function listUserTemplates() {
   const dir = getUserTemplateDir();
@@ -10456,14 +10383,14 @@ function listUserTemplates() {
     const files = (0, import_node_fs4.readdirSync)(dir);
     return files.filter((f) => f.endsWith(".json")).map((f) => ({
       name: f.replace(/\.json$/, ""),
-      filePath: (0, import_node_path9.join)(dir, f)
+      filePath: (0, import_node_path8.join)(dir, f)
     }));
   } catch {
     return [];
   }
 }
 function resolveUserTemplate(name) {
-  const filePath = (0, import_node_path9.join)(getUserTemplateDir(), `${name}.json`);
+  const filePath = (0, import_node_path8.join)(getUserTemplateDir(), `${name}.json`);
   if ((0, import_node_fs4.existsSync)(filePath)) {
     return filePath;
   }
@@ -10478,27 +10405,27 @@ var saasLifecycle = {
     {
       name: "trial",
       weight: 0.12,
-      columnValues: {}
+      columnValues: { status: "active" }
     },
     {
       name: "active",
       weight: 0.65,
-      columnValues: {}
+      columnValues: { status: "active" }
     },
     {
       name: "churned",
       weight: 0.1,
-      columnValues: {}
+      columnValues: { status: "inactive" }
     },
     {
       name: "past_due",
       weight: 0.08,
-      columnValues: {}
+      columnValues: { status: "active" }
     },
     {
       name: "paused",
       weight: 0.05,
-      columnValues: {}
+      columnValues: { status: "inactive" }
     }
   ],
   transitions: [
@@ -10510,7 +10437,7 @@ var saasLifecycle = {
         {
           table: "subscriptions",
           action: "create",
-          values: { status: "active", plan: "Professional" }
+          values: { status: "active" }
         },
         {
           table: "payments",
@@ -10613,20 +10540,6 @@ var saasLifecycle = {
     }
   ],
   correlations: [
-    {
-      description: "Enterprise plan users have 2x more payments (longer tenure)",
-      condition: {
-        table: "subscriptions",
-        column: "plan",
-        operator: "eq",
-        value: "Enterprise"
-      },
-      effect: {
-        table: "payments",
-        column: "amount_cents",
-        multiplier: 2
-      }
-    },
     {
       description: "Churned users always have a failed payment before cancel",
       condition: {
@@ -11731,53 +11644,13 @@ async function seedDatabase(config, options) {
       throw new Error(`Generation plan validation failed:
 ${validation.errors.join("\n")}`);
     }
-    let dataset;
     const lifecycleUsed = !!options?.lifecycle;
+    let dataset = timelineConfig ? generateTimelineDataset(plan, timelineConfig) : generateDataset(plan);
     if (options?.lifecycle && options?.template) {
       const lifecycle = resolveLifecycle(options.template);
       if (lifecycle) {
-        const random = createSeededRandom(plan.reproducibility.randomSeed);
-        const entityCount = effectiveConfig.seed.defaultRecords;
-        const simResult = simulateLifecycles(lifecycle, entityCount, random);
-        const correlatedResult = applyCorrelations(simResult, lifecycle.correlations, random);
-        const schemaColumnLookup = /* @__PURE__ */ new Map();
-        for (const table of schema.tables) {
-          schemaColumnLookup.set(table.name, new Set(table.columns.map((c) => c.name)));
-        }
-        const tables = /* @__PURE__ */ new Map();
-        let totalRows = 0;
-        for (const [tableName, rows] of correlatedResult.tables) {
-          const validColumns = schemaColumnLookup.get(tableName);
-          const filteredRows = validColumns ? rows.map((row) => {
-            const filtered = {};
-            for (const [col, val] of Object.entries(row)) {
-              if (validColumns.has(col)) {
-                filtered[col] = val;
-              } else {
-                console.warn(`[lifecycle] Skipping column '${col}' on table '${tableName}' \u2014 column does not exist`);
-              }
-            }
-            return filtered;
-          }) : rows;
-          tables.set(tableName, {
-            tableName,
-            columns: filteredRows.length > 0 ? Object.keys(filteredRows[0]) : [],
-            rows: filteredRows,
-            rowCount: filteredRows.length
-          });
-          totalRows += filteredRows.length;
-        }
-        dataset = {
-          tables,
-          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          seed: plan.reproducibility.randomSeed,
-          totalRows
-        };
-      } else {
-        dataset = timelineConfig ? generateTimelineDataset(plan, timelineConfig) : generateDataset(plan);
+        dataset = applyLifecycleOverlay(dataset, lifecycle, plan, schema);
       }
-    } else {
-      dataset = timelineConfig ? generateTimelineDataset(plan, timelineConfig) : generateDataset(plan);
     }
     let scenariosApplied;
     let scenarioReportData;
@@ -11819,6 +11692,66 @@ ${validation.errors.join("\n")}`);
     await closeConnection(pool);
   }
 }
+function applyLifecycleOverlay(dataset, lifecycle, plan, schema) {
+  const random = createSeededRandom(plan.reproducibility.randomSeed);
+  const rootTable = dataset.tables.get(lifecycle.rootTable);
+  const entityCount = rootTable?.rowCount ?? plan.tables[0]?.rowCount ?? 0;
+  const simResult = simulateLifecycles(lifecycle, entityCount, random);
+  const correlatedResult = applyCorrelations(simResult, lifecycle.correlations, random);
+  const schemaColumnLookup = /* @__PURE__ */ new Map();
+  for (const table of schema.tables) {
+    schemaColumnLookup.set(table.name, new Set(table.columns.map((c) => c.name)));
+  }
+  const warnedColumns = /* @__PURE__ */ new Set();
+  if (rootTable) {
+    const lifecycleRootRows = correlatedResult.tables.get(lifecycle.rootTable);
+    if (lifecycleRootRows) {
+      const validColumns = schemaColumnLookup.get(lifecycle.rootTable);
+      const count = Math.min(rootTable.rows.length, lifecycleRootRows.length);
+      for (let i = 0; i < count; i++) {
+        for (const [col, val] of Object.entries(lifecycleRootRows[i])) {
+          if (col === "id")
+            continue;
+          if (validColumns && !validColumns.has(col)) {
+            const key = `${lifecycle.rootTable}.${col}`;
+            if (!warnedColumns.has(key)) {
+              console.warn(`[lifecycle] Skipping column '${col}' on table '${lifecycle.rootTable}' \u2014 does not exist in schema`);
+              warnedColumns.add(key);
+            }
+            continue;
+          }
+          rootTable.rows[i][col] = val;
+        }
+      }
+    }
+  }
+  for (const [tableName, lifecycleRows] of correlatedResult.tables) {
+    if (tableName === lifecycle.rootTable)
+      continue;
+    const existingTable = dataset.tables.get(tableName);
+    if (!existingTable || lifecycleRows.length === 0)
+      continue;
+    const validColumns = schemaColumnLookup.get(tableName);
+    const entityIdCol = `${lifecycle.entityName}_id`;
+    const count = Math.min(lifecycleRows.length, existingTable.rows.length);
+    for (let i = 0; i < count; i++) {
+      for (const [col, val] of Object.entries(lifecycleRows[i])) {
+        if (col === "id" || col === entityIdCol)
+          continue;
+        if (validColumns && !validColumns.has(col)) {
+          const key = `${tableName}.${col}`;
+          if (!warnedColumns.has(key)) {
+            console.warn(`[lifecycle] Skipping column '${col}' on table '${tableName}' \u2014 does not exist in schema`);
+            warnedColumns.add(key);
+          }
+          continue;
+        }
+        existingTable.rows[i][col] = val;
+      }
+    }
+  }
+  return dataset;
+}
 function computeTotalMonths(tc) {
   const start = new Date(tc.startDate);
   const end = new Date(tc.endDate);
@@ -12194,7 +12127,7 @@ async function captureDatabase(config, options) {
 }
 
 // ../../packages/core/dist/sharePipeline.js
-var import_promises9 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 
 // ../../packages/core/dist/sharing/gistUpload.js
 var import_node_https = __toESM(require("https"), 1);
@@ -12282,11 +12215,11 @@ function formatSize(bytes) {
 }
 async function shareRealityPack(filePath, options) {
   const pack = await loadRealityPack(filePath);
-  const fileStat = await (0, import_promises9.stat)(filePath);
+  const fileStat = await (0, import_promises8.stat)(filePath);
   const size = formatSize(fileStat.size);
   const method = options?.method ?? "file";
   if (method === "gist") {
-    const content = await (0, import_promises9.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises8.readFile)(filePath, "utf-8");
     const compressed = await compressPack(content);
     const compressedSize = formatSize(compressed.length);
     const filename = `${pack.metadata.name}.realitydb-pack.json`;
@@ -12758,12 +12691,322 @@ function maskConnectionString(connectionString) {
   }
 }
 
+// src/commands/init.ts
+var CONFIG_FILE = "realitydb.config.json";
+var DEFAULT_CONNECTION = "postgres://postgres:postgres@localhost:5432/myapp_dev";
+function ask(rl, prompt) {
+  return new Promise((resolve12) => {
+    rl.question(prompt, (answer) => {
+      resolve12(answer);
+    });
+  });
+}
+async function initCommand() {
+  const rl = (0, import_node_readline.createInterface)({ input: import_node_process.stdin, output: import_node_process.stdout });
+  rl.on("close", () => {
+    if (!wizardComplete) {
+      console.log("");
+      console.log("");
+      console.log("Init cancelled.");
+      console.log("");
+      process.exit(0);
+    }
+  });
+  let wizardComplete = false;
+  try {
+    console.log("");
+    console.log("Welcome to RealityDB");
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log("");
+    console.log("Let's connect to your database and fill it with realistic data.");
+    console.log("");
+    if ((0, import_node_fs7.existsSync)(CONFIG_FILE)) {
+      const overwrite = await ask(rl, `${CONFIG_FILE} already exists. Overwrite? (y/N) `);
+      if (overwrite.toLowerCase() !== "y") {
+        wizardComplete = true;
+        console.log("");
+        console.log("Init cancelled. Existing config preserved.");
+        console.log("");
+        return;
+      }
+      console.log("");
+    }
+    let connectionString;
+    let scanResult;
+    let masked;
+    while (true) {
+      console.log("Step 1: Database Connection");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      connectionString = await promptWithDefault(
+        rl,
+        "PostgreSQL connection string",
+        DEFAULT_CONNECTION
+      );
+      console.log("");
+      console.log("Step 2: Connecting & Scanning");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      masked = maskConnectionString(connectionString);
+      console.log(`  Connecting to ${masked}...`);
+      const scanConfig = {
+        database: { client: "postgres", connectionString },
+        seed: { defaultRecords: 50, batchSize: 1e3, environment: "dev" }
+      };
+      try {
+        scanResult = await scanDatabase(scanConfig);
+        break;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error("");
+        console.error(`  Connection failed: ${msg}`);
+        console.error("");
+        console.error("Hints:");
+        console.error("  - Is PostgreSQL running? (docker ps, pg_isready)");
+        console.error("  - Check host, port, username, password, and database name");
+        console.error("  - Ensure the database exists (createdb myapp_dev)");
+        console.error("");
+        const retry = await ask(rl, "Try a different connection string? (Y/n) ");
+        if (retry.toLowerCase() === "n") {
+          wizardComplete = true;
+          process.exit(1);
+        }
+        console.log("");
+      }
+    }
+    const { schema } = scanResult;
+    console.log("  Connected successfully.");
+    console.log("");
+    if (schema.tables.length === 0) {
+      wizardComplete = true;
+      console.log("  No tables found in the public schema.");
+      console.log("");
+      console.log("  Run your migrations first, then try again:");
+      console.log("    npx prisma migrate dev");
+      console.log("    npx knex migrate:latest");
+      console.log("    rails db:migrate");
+      console.log("");
+      process.exit(1);
+    }
+    console.log("Step 3: Schema");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`  Found ${schema.tables.length} tables, ${schema.foreignKeys.length} foreign keys`);
+    console.log("");
+    console.log("  Tables:");
+    for (const table of schema.tables) {
+      const colCount = table.columns.length;
+      const pkLabel = table.primaryKey ? ` PK: ${table.primaryKey.columnName}` : "";
+      console.log(`    ${table.name} (${colCount} cols${pkLabel})`);
+    }
+    console.log("");
+    console.log("Step 4: Template Selection");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    const registry = getDefaultRegistry();
+    const allTemplates = registry.list();
+    const detected = detectTemplate(schema.tables.map((t) => t.name), allTemplates);
+    let templateName;
+    if (detected) {
+      console.log(`  Auto-detected domain: ${detected.name}`);
+      console.log(`  ${detected.description}`);
+      console.log("");
+      const useDetected = await ask(rl, `  Use "${detected.name}" template? (Y/n) `);
+      if (useDetected.toLowerCase() !== "n") {
+        templateName = detected.name;
+      }
+    }
+    if (!templateName) {
+      console.log("");
+      console.log("  Available templates:");
+      for (let i = 0; i < allTemplates.length; i++) {
+        console.log(`    ${i + 1}. ${allTemplates[i].name} \u2014 ${allTemplates[i].description}`);
+      }
+      console.log(`    ${allTemplates.length + 1}. none \u2014 use schema-only generation`);
+      console.log("");
+      const choice = await ask(rl, `  Choose template (1-${allTemplates.length + 1}): `);
+      const choiceNum = parseInt(choice, 10);
+      if (choiceNum >= 1 && choiceNum <= allTemplates.length) {
+        templateName = allTemplates[choiceNum - 1].name;
+      }
+    }
+    console.log("");
+    console.log("Step 5: Configuration");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    const recordsStr = await promptWithDefault(rl, "Records per table", "50");
+    const records = parseInt(recordsStr, 10) || 50;
+    console.log("");
+    console.log("Step 6: Writing Config");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    const config = {
+      database: {
+        client: "postgres",
+        connectionString
+      },
+      seed: {
+        defaultRecords: records,
+        batchSize: 1e3,
+        environment: "dev",
+        randomSeed: 42
+      },
+      ...templateName ? { template: templateName } : {}
+    };
+    (0, import_node_fs7.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+    console.log(`  Created ${CONFIG_FILE}`);
+    console.log("");
+    const runSeed = await ask(rl, "Run initial seed now? (Y/n) ");
+    if (runSeed.toLowerCase() !== "n") {
+      console.log("");
+      console.log("Seeding...");
+      try {
+        const result = await seedDatabase(config, {
+          records,
+          seed: 42,
+          template: templateName
+        });
+        console.log("");
+        for (const tableResult of result.insertResult.tables) {
+          console.log(
+            `  ${tableResult.tableName}: ${tableResult.rowsInserted} rows`
+          );
+        }
+        const totalTime = (result.durationMs / 1e3).toFixed(1);
+        console.log("");
+        console.log(`  Seed complete. ${result.totalRows} rows in ${totalTime}s`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error("");
+        console.error(`  Seed failed: ${msg}`);
+        console.error("  You can retry later with: realitydb seed");
+      }
+    }
+    wizardComplete = true;
+    console.log("");
+    console.log("RealityDB initialized!");
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log(`  Config:   ./${CONFIG_FILE}`);
+    console.log(`  Database: ${masked}`);
+    if (templateName) {
+      console.log(`  Template: ${templateName}`);
+    }
+    console.log(`  Records:  ${records} per table`);
+    console.log("");
+    console.log("Next steps:");
+    console.log("  realitydb scan      Inspect your schema");
+    console.log("  realitydb seed      Generate data");
+    console.log("  realitydb export    Export without writing to DB");
+    console.log("  realitydb analyze   Generate a custom template");
+    console.log("  realitydb --help    See all commands");
+    console.log("");
+  } finally {
+    rl.close();
+  }
+}
+async function promptWithDefault(rl, label, defaultValue) {
+  console.log(`  ${label}`);
+  console.log(`  Default: ${defaultValue}`);
+  const answer = await ask(rl, "  > ");
+  return answer.trim() || defaultValue;
+}
+function detectTemplate(tableNames, templates) {
+  const lower = new Set(tableNames.map((t) => t.toLowerCase()));
+  let bestMatch = null;
+  let bestScore = 0;
+  for (const template of templates) {
+    let matches = 0;
+    for (const target of template.targetTables) {
+      if (lower.has(target.toLowerCase())) {
+        matches++;
+      }
+    }
+    if (matches >= 2 && matches > bestScore) {
+      bestScore = matches;
+      bestMatch = template;
+    }
+  }
+  return bestMatch;
+}
+
+// ../../packages/config/dist/loadConfig.js
+var import_promises9 = require("fs/promises");
+var import_node_path9 = require("path");
+
+// ../../packages/config/dist/defaults.js
+var DEFAULT_CONFIG = {
+  seed: {
+    defaultRecords: 5e3,
+    batchSize: 1e3,
+    environment: "dev"
+  },
+  export: {
+    defaultFormat: "json",
+    outputDir: "./.databox"
+  }
+};
+
+// ../../packages/config/dist/loadConfig.js
+var CONFIG_FILES = ["realitydb.config.json", "seedforge.config.json", "databox.config.json"];
+async function findConfigFile(basePath) {
+  for (const name of CONFIG_FILES) {
+    const fullPath = (0, import_node_path9.resolve)(basePath, name);
+    try {
+      await (0, import_promises9.access)(fullPath);
+      return fullPath;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function loadConfig(filePath) {
+  let resolvedPath;
+  if (filePath) {
+    resolvedPath = (0, import_node_path9.resolve)(filePath);
+  } else {
+    const found = await findConfigFile(".");
+    if (!found) {
+      throw new Error(`[realitydb] Config file not found.
+Create a realitydb.config.json or specify a path with --config.`);
+    }
+    resolvedPath = found;
+  }
+  let raw;
+  try {
+    raw = await (0, import_promises9.readFile)(resolvedPath, "utf-8");
+  } catch {
+    throw new Error(`[realitydb] Config file not found: ${resolvedPath}
+Create a realitydb.config.json or specify a path with --config.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`[realitydb] Invalid JSON in config file: ${resolvedPath}`);
+  }
+  const config = parsed;
+  const database = config["database"];
+  if (!database || typeof database["connectionString"] !== "string") {
+    throw new Error("[realitydb] Config validation failed: database.connectionString is required.");
+  }
+  return {
+    database: {
+      client: "postgres",
+      connectionString: database["connectionString"]
+    },
+    seed: {
+      ...DEFAULT_CONFIG.seed,
+      ...config["seed"] ?? {}
+    },
+    template: config["template"],
+    export: {
+      ...DEFAULT_CONFIG.export,
+      ...config["export"] ?? {}
+    }
+  };
+}
+
 // src/commands/scan.ts
 var VERSION2 = "0.10.0";
 async function scanCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const result = await scanDatabase(config);
     const { schema } = result;
     const masked = maskConnectionString(config.database.connectionString);
@@ -12883,7 +13126,7 @@ var VERSION3 = "1.3.1";
 async function seedCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const records = options.records ? parseInt(options.records, 10) : void 0;
     const seed = options.seed ? parseInt(options.seed, 10) : void 0;
     const rawTemplateName = options.template ?? config.template;
@@ -13093,7 +13336,7 @@ async function resetCommand(options) {
     process.exit(0);
   }
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
       console.log("");
@@ -13158,7 +13401,7 @@ var VERSION5 = "1.3.1";
 async function exportCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const format = options.format ?? config.export?.defaultFormat ?? "json";
     const outputDir = options.output ?? config.export?.outputDir ?? "./.realitydb";
     const records = options.records ? parseInt(options.records, 10) : void 0;
@@ -13311,7 +13554,7 @@ async function exportCommand(options) {
 }
 
 // src/commands/templates.ts
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var VERSION6 = "0.10.0";
 function templatesCommand() {
   const registry = getDefaultRegistry();
@@ -13338,7 +13581,7 @@ function templatesCommand() {
 }
 function templatesInitCommand() {
   const fileName = "realitydb.template.json";
-  if ((0, import_node_fs7.existsSync)(fileName)) {
+  if ((0, import_node_fs8.existsSync)(fileName)) {
     console.error(`[realitydb] ${fileName} already exists in this directory.`);
     process.exit(1);
   }
@@ -13372,7 +13615,7 @@ function templatesInitCommand() {
       }
     }
   };
-  (0, import_node_fs7.writeFileSync)(fileName, JSON.stringify(scaffold, null, 2) + "\n");
+  (0, import_node_fs8.writeFileSync)(fileName, JSON.stringify(scaffold, null, 2) + "\n");
   console.log("");
   console.log(`Created ${fileName}`);
   console.log("Edit this file to define your custom template.");
@@ -13383,7 +13626,7 @@ function templatesInitCommand() {
 }
 function templatesValidateCommand(filePath, options) {
   const start = performance.now();
-  if (!(0, import_node_fs7.existsSync)(filePath)) {
+  if (!(0, import_node_fs8.existsSync)(filePath)) {
     if (options.ci) {
       console.log(formatCIOutput({
         success: false,
@@ -13400,7 +13643,7 @@ function templatesValidateCommand(filePath, options) {
   }
   let json;
   try {
-    const raw = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
+    const raw = (0, import_node_fs8.readFileSync)(filePath, "utf-8");
     json = JSON.parse(raw);
   } catch {
     if (options.ci) {
@@ -13463,7 +13706,7 @@ function templatesValidateCommand(filePath, options) {
 }
 
 // src/commands/scenarios.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path12 = require("path");
 function scenariosCommand() {
   const registry = getDefaultScenarioRegistry();
@@ -13488,12 +13731,12 @@ function scenariosCreateCommand(name) {
   const sanitized = name.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-");
   const fileName = `${sanitized}.scenario.json`;
   const filePath = (0, import_node_path12.resolve)(fileName);
-  if ((0, import_node_fs8.existsSync)(filePath)) {
+  if ((0, import_node_fs9.existsSync)(filePath)) {
     console.error(`[realitydb] File already exists: ${fileName}`);
     process.exit(1);
   }
   const scaffold = scaffoldCustomScenario(sanitized);
-  (0, import_node_fs8.writeFileSync)(filePath, JSON.stringify(scaffold, null, 2) + "\n", "utf-8");
+  (0, import_node_fs9.writeFileSync)(filePath, JSON.stringify(scaffold, null, 2) + "\n", "utf-8");
   console.log("");
   console.log(`Created custom scenario: ${fileName}`);
   console.log("");
@@ -13518,7 +13761,7 @@ var import_node_path13 = require("path");
 var import_promises10 = require("fs/promises");
 async function packExportCommand(options) {
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const records = options.records ? parseInt(options.records, 10) : void 0;
     const seed = options.seed ? parseInt(options.seed, 10) : void 0;
     const rawTemplateName = options.template ?? config.template;
@@ -13620,7 +13863,7 @@ async function packImportCommand(filePath, options) {
       console.error("Usage: realitydb pack import <file> --confirm");
       process.exit(1);
     }
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     const pack = await loadRealityPack(filePath);
     console.log("");
@@ -13689,7 +13932,7 @@ async function captureCommand(options) {
       console.error("Usage: realitydb capture --name <name>");
       process.exit(1);
     }
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     const tables = options.tables ? options.tables.split(",").map((t) => t.trim()).filter((t) => t.length > 0) : void 0;
     if (!options.ci) {
@@ -13935,7 +14178,7 @@ async function loadCommand(filePath, options) {
       }
       return;
     }
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
       console.log("");
@@ -14248,13 +14491,13 @@ function getDefaultSchema() {
 }
 
 // src/commands/analyze.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_path16 = require("path");
 var VERSION12 = "1.3.1";
 async function analyzeCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const sampleSize = options.sampleSize ? parseInt(options.sampleSize, 10) : 1e3;
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
@@ -14290,14 +14533,14 @@ async function analyzeCommand(options) {
       }));
       if (result.templateJson && options.output) {
         const filePath = (0, import_node_path16.resolve)(options.output);
-        (0, import_node_fs9.writeFileSync)(filePath, result.templateJson + "\n", "utf-8");
+        (0, import_node_fs10.writeFileSync)(filePath, result.templateJson + "\n", "utf-8");
       }
       return;
     }
     console.log(formatAnalysisReport(result.report));
     if (result.templateJson && options.output) {
       const filePath = (0, import_node_path16.resolve)(options.output);
-      (0, import_node_fs9.writeFileSync)(filePath, result.templateJson + "\n", "utf-8");
+      (0, import_node_fs10.writeFileSync)(filePath, result.templateJson + "\n", "utf-8");
       console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
       console.log(`Template generated: ${filePath}`);
       console.log("");
@@ -14342,13 +14585,13 @@ async function analyzeCommand(options) {
 }
 
 // src/commands/mask.ts
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_path17 = require("path");
 var VERSION13 = "1.3.1";
 async function maskCommand(options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const mode = options.mode ?? "gdpr";
     const seed = options.seed ? parseInt(options.seed, 10) : void 0;
     const dryRun = options.dryRun ?? false;
@@ -14420,7 +14663,7 @@ async function maskCommand(options) {
     const durationMs = Math.round(performance.now() - start);
     if (options.auditLog) {
       const auditPath = (0, import_node_path17.resolve)(options.auditLog);
-      (0, import_node_fs10.writeFileSync)(auditPath, serializeAuditLog(result.auditLog) + "\n", "utf-8");
+      (0, import_node_fs11.writeFileSync)(auditPath, serializeAuditLog(result.auditLog) + "\n", "utf-8");
     }
     if (options.ci) {
       console.log(formatCIOutput({
@@ -14495,7 +14738,7 @@ async function maskCommand(options) {
 }
 
 // src/commands/classroom.ts
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_path18 = require("path");
 var VERSION14 = "1.3.1";
 async function classroomListCommand(options) {
@@ -14557,7 +14800,7 @@ async function classroomListCommand(options) {
 async function classroomStartCommand(courseName, options) {
   const start = performance.now();
   try {
-    const config = await loadConfig();
+    const config = await loadConfig(options.configPath);
     const masked = maskConnectionString(config.database.connectionString);
     if (!options.ci) {
       console.log("");
@@ -14760,7 +15003,7 @@ async function classroomCreateCommand(name, options) {
     const content = classroomCreate(name);
     const filename = `${name}.course.json`;
     const filePath = (0, import_node_path18.resolve)(filename);
-    (0, import_node_fs11.writeFileSync)(filePath, content + "\n", "utf-8");
+    (0, import_node_fs12.writeFileSync)(filePath, content + "\n", "utf-8");
     const durationMs = Math.round(performance.now() - start);
     if (options.ci) {
       console.log(formatCIOutput({
@@ -15010,33 +15253,36 @@ async function simulateWebhooksCommand(options) {
 }
 
 // src/cli.ts
-var VERSION16 = "1.3.1";
+var VERSION16 = "1.5.0";
 function run(argv) {
   const program2 = new Command();
   program2.name("realitydb").description("RealityDB \u2014 Developer Reality Platform").version(VERSION16).option("--config <path>", "Path to config file").option("--ci", "CI mode: JSON output, no prompts, proper exit codes", false).option("--verbose", "Enable verbose output", false);
+  program2.command("init").description("Interactive setup wizard \u2014 connect, scan, and seed in one step").action(async () => {
+    await initCommand();
+  });
   program2.command("scan").description("Scan database schema").action(async () => {
     const opts = program2.opts();
-    await scanCommand({ ci: opts.ci });
+    await scanCommand({ ci: opts.ci, configPath: opts.config });
   });
   program2.command("analyze").description("Analyze database schema and suggest column strategies").option("--output <file>", "Generate a template JSON file from analysis").option("--sample-size <count>", "Number of rows to sample per table", "1000").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await analyzeCommand({ ...cmdOpts, ci: opts.ci });
+    await analyzeCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("seed").description("Seed database with generated data").option("--records <count>", "Number of records per table").option("--template <name|path>", "Template name or path to custom .json file").option("--seed <number>", "Random seed for reproducibility").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').option("--lifecycle", "Enable lifecycle simulation for causally-connected data").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await seedCommand({ ...cmdOpts, ci: opts.ci });
+    await seedCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("reset").description("Reset seeded data").option("--confirm", "Confirm destructive operation").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await resetCommand({ ...cmdOpts, ci: opts.ci });
+    await resetCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("export").description("Export generated data").option("--format <format>", "Output format (json|csv|sql)", "json").option("--output <dir>", "Output directory", "./.realitydb").option("--records <count>", "Number of records per table").option("--seed <number>", "Random seed for reproducibility").option("--template <name>", "Template to use").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').action(async (cmdOpts) => {
     const opts = program2.opts();
-    await exportCommand({ ...cmdOpts, ci: opts.ci });
+    await exportCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("generate").description("Generate large-scale datasets for data science (no database required)").option("--records <count>", "Number of records to generate", "1000").option("--schema <file>", "Schema definition file (.sql or .json)").option("--format <format>", "Output format (json|csv|parquet)", "json").option("--output <dir>", "Output directory", "./.realitydb/generated").option("--seed <number>", "Random seed for reproducibility").option("--table <name>", "Generate only a specific table").option("--correlations", "Enable cross-column correlations from schema").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await generateCommand({ ...cmdOpts, ci: opts.ci });
+    await generateCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   const templates = program2.command("templates").description("Template management");
   templates.command("list", { isDefault: true }).description("List available domain templates").action(templatesCommand);
@@ -15052,61 +15298,67 @@ function run(argv) {
   });
   program2.command("mask").description("Detect and mask PII in your database").option("--mode <mode>", "Compliance mode (hipaa|gdpr|strict)", "gdpr").option("--seed <number>", "Random seed for deterministic masking").option("--dry-run", "Preview PII detection without modifying data").option("--output <dir>", "Export masked data to files instead of writing to DB").option("--output-format <format>", "Output format (json|csv|sql)", "json").option("--audit-log <file>", "Write audit log to file").option("--confirm", "Confirm writing masked data back to database").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await maskCommand({ ...cmdOpts, ci: opts.ci });
+    await maskCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   const classroom = program2.command("classroom").description("Education and classroom mode");
   classroom.command("list", { isDefault: true }).description("List available courses").action(async () => {
     const opts = program2.opts();
-    await classroomListCommand({ ci: opts.ci });
+    await classroomListCommand({ ci: opts.ci, configPath: opts.config });
   });
   classroom.command("start <course>").description("Load a course into your database").action(async (course) => {
     const opts = program2.opts();
-    await classroomStartCommand(course, { ci: opts.ci });
+    await classroomStartCommand(course, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("status [course]").description("Show progress for all courses or a specific course").action(async (course) => {
     const opts = program2.opts();
-    await classroomStatusCommand(course, { ci: opts.ci });
+    await classroomStatusCommand(course, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("complete <course> <exercise>").description("Mark an exercise as completed").action(async (course, exercise) => {
     const opts = program2.opts();
-    await classroomCompleteCommand(course, exercise, { ci: opts.ci });
+    await classroomCompleteCommand(course, exercise, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("reset <course>").description("Reset progress for a course").action(async (course) => {
     const opts = program2.opts();
-    await classroomResetCommand(course, { ci: opts.ci });
+    await classroomResetCommand(course, { ci: opts.ci, configPath: opts.config });
   });
   classroom.command("create <name>").description("Scaffold a custom course JSON file").action(async (name) => {
     const opts = program2.opts();
-    await classroomCreateCommand(name, { ci: opts.ci });
+    await classroomCreateCommand(name, { ci: opts.ci, configPath: opts.config });
   });
   const simulate = program2.command("simulate").description("System behavior simulation");
   simulate.command("run", { isDefault: true }).description("Run a simulation with a profile").option("--profile <name>", "Simulation profile (saas-startup|ecommerce-peak|api-service)", "saas-startup").option("--duration <duration>", "Override profile duration (e.g., 1-hour, 1-day, 1-week)").option("--events <count>", "Number of events to generate", "1000").option("--seed <number>", "Random seed for reproducibility").option("--output <file>", "Output file path").option("--format <format>", "Output format (json|ndjson)", "json").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await simulateRunCommand({ ...cmdOpts, ci: opts.ci });
+    await simulateRunCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   simulate.command("profiles").description("List available simulation profiles").action(async () => {
     const opts = program2.opts();
-    await simulateProfilesCommand({ ci: opts.ci });
+    await simulateProfilesCommand({ ci: opts.ci, configPath: opts.config });
   });
   simulate.command("webhooks").description("Generate webhook events from a specific source").option("--source <source>", "Webhook source (stripe|github)", "stripe").option("--events <count>", "Number of events to generate", "100").option("--seed <number>", "Random seed for reproducibility").option("--output <file>", "Output file path").option("--format <format>", "Output format (json|ndjson)", "json").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await simulateWebhooksCommand({ ...cmdOpts, ci: opts.ci });
+    await simulateWebhooksCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("capture").description("Capture live database state into a Reality Pack").requiredOption("--name <name>", "Name for the captured pack").option("--description <desc>", "Pack description").option("--tables <tables>", "Comma-separated list of tables to capture").option("--output <dir>", "Output directory", ".").action(async (cmdOpts) => {
     const opts = program2.opts();
-    await captureCommand({ ...cmdOpts, ci: opts.ci });
+    await captureCommand({ ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("share <file>").description("Share a Reality Pack file").option("--gist", "Upload to GitHub Gist").option("--description <desc>", "Gist description").action(async (filePath, cmdOpts) => {
     const opts = program2.opts();
-    await shareCommand(filePath, { ...cmdOpts, ci: opts.ci });
+    await shareCommand(filePath, { ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   program2.command("load <file>").description("Load a Reality Pack into the database (file path or URL)").option("--confirm", "Confirm import operation").option("--show-ddl", "Show schema DDL without importing").action(async (filePath, cmdOpts) => {
     const opts = program2.opts();
-    await loadCommand(filePath, { ...cmdOpts, ci: opts.ci });
+    await loadCommand(filePath, { ...cmdOpts, ci: opts.ci, configPath: opts.config });
   });
   const pack = program2.command("pack").description("Reality Pack operations");
-  pack.command("export").description("Export environment as Reality Pack").option("--name <name>", "Pack name").option("--description <desc>", "Pack description").option("--output <dir>", "Output directory", ".").option("--records <count>", "Number of records per table").option("--seed <number>", "Random seed for reproducibility").option("--template <name>", "Template to use").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').action(packExportCommand);
-  pack.command("import <file>").description("Import Reality Pack into database").option("--confirm", "Confirm import operation").action(packImportCommand);
+  pack.command("export").description("Export environment as Reality Pack").option("--name <name>", "Pack name").option("--description <desc>", "Pack description").option("--output <dir>", "Output directory", ".").option("--records <count>", "Number of records per table").option("--seed <number>", "Random seed for reproducibility").option("--template <name>", "Template to use").option("--timeline <duration>", 'Timeline duration (e.g., "12-months", "1-year")').option("--scenario <names>", "Scenarios to apply (comma-separated)").option("--scenario-intensity <level>", "Scenario intensity (low|medium|high)", "medium").option("--scenario-schedule <schedule>", 'Timeline-scheduled scenarios (e.g., "fraud-spike:month-6,churn-spike:month-9")').action(async (cmdOpts) => {
+    const opts = program2.opts();
+    await packExportCommand({ ...cmdOpts, configPath: opts.config });
+  });
+  pack.command("import <file>").description("Import Reality Pack into database").option("--confirm", "Confirm import operation").action(async (filePath, cmdOpts) => {
+    const opts = program2.opts();
+    await packImportCommand(filePath, { ...cmdOpts, configPath: opts.config });
+  });
   const packs = program2.command("packs").description("Browse available Reality Packs");
   packs.command("list", { isDefault: true }).description("List available demo packs").action(() => {
     const opts = program2.opts();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "realitydb",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "Developer Reality Platform - realistic database environments from your schema",
   "license": "MIT",
   "keywords": [
@@ -59,4 +59,3 @@
     "pg": "^8.20.0"
   }
 }
-