realitydb 0.2.0 → 0.3.0

package/dist/index.js

@@ -6150,6 +6150,13 @@ async function truncateTables(pool, tableNames, cascade) {
   };
 }
 
+// ../../packages/db/dist/readTable.js
+async function readTableRows(pool, tableName, columns) {
+  const quotedColumns = columns.map((c) => `"${c}"`).join(", ");
+  const result = await pool.query(`SELECT ${quotedColumns} FROM "${tableName}"`);
+  return result.rows;
+}
+
 // ../../packages/schema/dist/normalizer.js
 function normalizeSchema(raw) {
   const primaryKeyMap = /* @__PURE__ */ new Map();
@@ -6340,6 +6347,85 @@ async function introspectDatabase(pool, schemaName = "public") {
   return schema;
 }
 
+// ../../packages/schema/dist/generateDDL.js
+function generateCreateTableDDL(schema) {
+  const orderedNames = orderByDependency(schema.tables, schema.foreignKeys);
+  const tableMap = /* @__PURE__ */ new Map();
+  for (const table of schema.tables) {
+    tableMap.set(table.name, table);
+  }
+  const fksBySource = /* @__PURE__ */ new Map();
+  for (const fk of schema.foreignKeys) {
+    const existing = fksBySource.get(fk.sourceTable) ?? [];
+    existing.push(fk);
+    fksBySource.set(fk.sourceTable, existing);
+  }
+  const statements = [];
+  for (const tableName of orderedNames) {
+    const table = tableMap.get(tableName);
+    if (!table)
+      continue;
+    const columnDefs = table.columns.sort((a, b) => a.ordinalPosition - b.ordinalPosition).map((col) => formatColumnDef(col));
+    if (table.primaryKey) {
+      columnDefs.push(`  PRIMARY KEY ("${table.primaryKey.columnName}")`);
+    }
+    const tableFks = fksBySource.get(tableName) ?? [];
+    for (const fk of tableFks) {
+      columnDefs.push(`  FOREIGN KEY ("${fk.sourceColumn}") REFERENCES "${fk.targetTable}" ("${fk.targetColumn}")`);
+    }
+    statements.push(`CREATE TABLE "${tableName}" (
+${columnDefs.join(",\n")}
+);`);
+  }
+  return statements.join("\n\n") + "\n";
+}
+function formatColumnDef(col) {
+  let typeName = col.dataType.toUpperCase();
+  if (col.maxLength && (typeName === "CHARACTER VARYING" || typeName === "VARCHAR")) {
+    typeName = `VARCHAR(${col.maxLength})`;
+  }
+  let def = `  "${col.name}" ${typeName}`;
+  if (!col.isNullable) {
+    def += " NOT NULL";
+  }
+  if (col.hasDefault && col.defaultValue !== null) {
+    def += ` DEFAULT ${col.defaultValue}`;
+  }
+  return def;
+}
+function orderByDependency(tables, foreignKeys) {
+  const tableNames = new Set(tables.map((t) => t.name));
+  const deps = /* @__PURE__ */ new Map();
+  for (const name of tableNames) {
+    deps.set(name, /* @__PURE__ */ new Set());
+  }
+  for (const fk of foreignKeys) {
+    if (fk.sourceTable !== fk.targetTable && tableNames.has(fk.targetTable)) {
+      deps.get(fk.sourceTable).add(fk.targetTable);
+    }
+  }
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name))
+      return;
+    if (visiting.has(name))
+      return;
+    visiting.add(name);
+    for (const dep of deps.get(name) ?? []) {
+      visit(dep);
+    }
+    visiting.delete(name);
+    visited.add(name);
+    result.push(name);
+  }
+  for (const name of tableNames) {
+    visit(name);
+  }
+  return result;
+}
+
 // ../../packages/core/dist/scanPipeline.js
 async function scanDatabase(config) {
   const pool = createPostgresClient(config.database.connectionString);
@@ -6628,6 +6714,198 @@ function packDatasetToGenerated(pack) {
   };
 }
 
+// ../../packages/core/dist/capturePipeline.js
+function maskConnection(connectionString) {
+  try {
+    const url = new URL(connectionString);
+    if (url.password) {
+      url.password = "****";
+    }
+    return url.toString();
+  } catch {
+    return connectionString.replace(/:([^@/]+)@/, ":****@");
+  }
+}
+async function captureDatabase(config, options) {
+  const start = performance.now();
+  const pool = createPostgresClient(config.database.connectionString);
+  try {
+    await testConnection(pool);
+    const schema = await introspectDatabase(pool);
+    const graph = buildDependencyGraph(schema.foreignKeys);
+    const sorted = topologicalSort(graph);
+    const graphOrder = sorted.order;
+    const allTableNames = schema.tables.map((t) => t.name);
+    const tableOrder = [
+      ...graphOrder,
+      ...allTableNames.filter((t) => !graphOrder.includes(t))
+    ];
+    let tablesToCapture;
+    if (options.tables && options.tables.length > 0) {
+      let addDeps2 = function(tableName) {
+        if (allDeps.has(tableName))
+          return;
+        allDeps.add(tableName);
+        for (const fk of schema.foreignKeys) {
+          if (fk.sourceTable === tableName && fk.sourceTable !== fk.targetTable) {
+            addDeps2(fk.targetTable);
+          }
+        }
+      };
+      var addDeps = addDeps2;
+      const requested = new Set(options.tables);
+      const allDeps = /* @__PURE__ */ new Set();
+      for (const t of requested) {
+        addDeps2(t);
+      }
+      tablesToCapture = tableOrder.filter((t) => allDeps.has(t));
+    } else {
+      tablesToCapture = tableOrder;
+    }
+    const capturedTableSet = new Set(tablesToCapture);
+    const filteredTables = schema.tables.filter((t) => capturedTableSet.has(t.name));
+    const filteredFKs = schema.foreignKeys.filter((fk) => capturedTableSet.has(fk.sourceTable) && capturedTableSet.has(fk.targetTable));
+    const filteredSchema = {
+      ...schema,
+      tables: filteredTables,
+      foreignKeys: filteredFKs,
+      tableCount: filteredTables.length,
+      foreignKeyCount: filteredFKs.length
+    };
+    const ddl = generateCreateTableDDL(filteredSchema);
+    const packDataset = { tables: {} };
+    const tableDetails = [];
+    let totalRows = 0;
+    for (const tableName of tablesToCapture) {
+      const tableSchema = filteredTables.find((t) => t.name === tableName);
+      if (!tableSchema)
+        continue;
+      const columns = tableSchema.columns.map((c) => c.name);
+      const rows = await readTableRows(pool, tableName, columns);
+      const rowCount = rows.length;
+      packDataset.tables[tableName] = {
+        columns,
+        rows,
+        rowCount
+      };
+      tableDetails.push({ name: tableName, rowCount });
+      totalRows += rowCount;
+    }
+    const packSchema = {
+      tables: filteredTables.map((t) => ({
+        name: t.name,
+        columns: t.columns.map((c) => ({
+          name: c.name,
+          dataType: c.dataType,
+          nullable: c.isNullable,
+          maxLength: c.maxLength
+        })),
+        primaryKey: t.primaryKey?.columnName
+      })),
+      foreignKeys: filteredFKs.map((fk) => ({
+        sourceTable: fk.sourceTable,
+        sourceColumn: fk.sourceColumn,
+        targetTable: fk.targetTable,
+        targetColumn: fk.targetColumn
+      }))
+    };
+    const plan = {
+      version: "1.0",
+      planId: `capture-${options.name}-${Date.now()}`,
+      tables: [],
+      tableOrder: tablesToCapture,
+      config: {
+        targetDatabase: "postgres",
+        defaultRowCount: 0,
+        batchSize: config.seed?.batchSize ?? 1e3,
+        environment: "dev"
+      },
+      reproducibility: {
+        randomSeed: 0,
+        strategyVersion: "0.3.0"
+      }
+    };
+    const masked = maskConnection(config.database.connectionString);
+    const pack = {
+      format: "databox-reality-pack",
+      version: "1.0",
+      metadata: {
+        name: options.name,
+        description: options.description,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        seed: 0,
+        totalRows,
+        tableCount: tablesToCapture.length,
+        ddl,
+        capturedFrom: masked
+      },
+      schema: packSchema,
+      plan,
+      dataset: packDataset
+    };
+    const outputDir = options.outputDir ?? ".";
+    const filePath = await saveRealityPack(pack, outputDir);
+    const durationMs = Math.round(performance.now() - start);
+    return {
+      pack,
+      filePath,
+      totalRows,
+      tableCount: tablesToCapture.length,
+      durationMs,
+      tableDetails
+    };
+  } finally {
+    await closeConnection(pool);
+  }
+}
+
+// ../../packages/core/dist/sharePipeline.js
+var import_promises6 = require("fs/promises");
+function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  const kb = Math.round(bytes / 1024);
+  if (kb < 1024)
+    return `${kb} KB`;
+  const mb = (bytes / (1024 * 1024)).toFixed(1);
+  return `${mb} MB`;
+}
+async function shareRealityPack(filePath, options) {
+  const pack = await loadRealityPack(filePath);
+  const fileStat = await (0, import_promises6.stat)(filePath);
+  const size = formatSize(fileStat.size);
+  const method = options?.method ?? "file";
+  if (method === "gist") {
+    const token = process.env.GITHUB_TOKEN;
+    if (!token) {
+      return {
+        method: "file",
+        location: filePath,
+        packName: pack.metadata.name,
+        size,
+        tableCount: pack.metadata.tableCount,
+        totalRows: pack.metadata.totalRows
+      };
+    }
+    return {
+      method: "file",
+      location: filePath,
+      packName: pack.metadata.name,
+      size,
+      tableCount: pack.metadata.tableCount,
+      totalRows: pack.metadata.totalRows
+    };
+  }
+  return {
+    method: "file",
+    location: filePath,
+    packName: pack.metadata.name,
+    size,
+    tableCount: pack.metadata.tableCount,
+    totalRows: pack.metadata.totalRows
+  };
+}
+
 // src/utils.ts
 function maskConnectionString(connectionString) {
   try {
@@ -6642,7 +6920,7 @@ function maskConnectionString(connectionString) {
 }
 
 // src/commands/scan.ts
-var VERSION2 = "0.2.0";
+var VERSION2 = "0.3.0";
 async function scanCommand(options) {
   const start = performance.now();
   try {
@@ -6733,7 +7011,7 @@ async function scanCommand(options) {
 }
 
 // src/commands/seed.ts
-var VERSION3 = "0.2.0";
+var VERSION3 = "0.3.0";
 async function seedCommand(options) {
   const start = performance.now();
   try {
@@ -6911,7 +7189,7 @@ async function seedCommand(options) {
 }
 
 // src/commands/reset.ts
-var VERSION4 = "0.2.0";
+var VERSION4 = "0.3.0";
 async function resetCommand(options) {
   const start = performance.now();
   if (!options.ci && !options.confirm) {
@@ -6981,7 +7259,7 @@ async function resetCommand(options) {
 }
 
 // src/commands/export.ts
-var VERSION5 = "0.2.0";
+var VERSION5 = "0.3.0";
 async function exportCommand(options) {
   const start = performance.now();
   try {
@@ -7174,7 +7452,7 @@ function scenariosCommand() {
 }
 
 // src/commands/pack.ts
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 async function packExportCommand(options) {
   try {
     const config = await loadConfig();
@@ -7251,7 +7529,7 @@ async function packExportCommand(options) {
       scenarios: options.scenario,
       scenarioIntensity
     });
-    const fileStat = await (0, import_promises6.stat)(result.filePath);
+    const fileStat = await (0, import_promises7.stat)(result.filePath);
     const sizeKb = Math.round(fileStat.size / 1024);
     console.log("");
     console.log(`Tables: ${result.pack.metadata.tableCount}`);
@@ -7331,11 +7609,330 @@ async function packImportCommand(filePath, options) {
   }
 }
 
+// src/commands/capture.ts
+var import_promises8 = require("fs/promises");
+var VERSION6 = "0.3.0";
+async function captureCommand(options) {
+  const start = performance.now();
+  try {
+    if (!options.name) {
+      const msg = "Missing required --name flag.";
+      if (options.ci) {
+        console.log(formatCIOutput({
+          success: false,
+          command: "capture",
+          version: VERSION6,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: 0,
+          error: msg
+        }));
+        process.exit(1);
+      }
+      console.error(`[realitydb] ${msg}`);
+      console.error("Usage: realitydb capture --name <name>");
+      process.exit(1);
+    }
+    const config = await loadConfig();
+    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) {
+      console.log("");
+      console.log("RealityDB Capture");
+      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(`Database: ${masked}`);
+      console.log(`Name: ${options.name}`);
+      if (tables) {
+        console.log(`Tables: ${tables.join(", ")}`);
+      }
+      console.log("");
+      console.log("Capturing...");
+    }
+    const result = await captureDatabase(config, {
+      name: options.name,
+      description: options.description,
+      tables,
+      outputDir: options.output
+    });
+    const durationMs = Math.round(performance.now() - start);
+    if (options.ci) {
+      console.log(formatCIOutput({
+        success: true,
+        command: "capture",
+        version: VERSION6,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        data: {
+          database: masked,
+          name: options.name,
+          filePath: result.filePath,
+          tableCount: result.tableCount,
+          totalRows: result.totalRows,
+          tables: result.tableDetails.map((t) => ({
+            name: t.name,
+            rowCount: t.rowCount
+          })),
+          ddlIncluded: true
+        }
+      }));
+      return;
+    }
+    for (const table of result.tableDetails) {
+      console.log(`  ${table.name}: ${table.rowCount} rows`);
+    }
+    const fileStat = await (0, import_promises8.stat)(result.filePath);
+    const sizeKb = Math.round(fileStat.size / 1024);
+    console.log("");
+    console.log(`Captured: ${result.filePath} (${sizeKb} KB)`);
+    console.log("Schema DDL included. Share this file to reproduce the environment.");
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.ci) {
+      console.log(formatCIOutput({
+        success: false,
+        command: "capture",
+        version: VERSION6,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Math.round(performance.now() - start),
+        error: message
+      }));
+      process.exit(1);
+    }
+    if (message.includes("Config file not found")) {
+      console.error(`[realitydb] ${message}`);
+    } else if (message.includes("connection") || message.includes("ECONNREFUSED")) {
+      console.error(`[realitydb] Capture failed: ${message}`);
+      console.error("Hint: Check that your database is running (e.g. Docker)");
+    } else {
+      console.error(`[realitydb] Capture failed: ${message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/share.ts
+var VERSION7 = "0.3.0";
+async function shareCommand(filePath, options) {
+  const start = performance.now();
+  try {
+    if (!filePath) {
+      const msg = "Missing file path argument.";
+      if (options.ci) {
+        console.log(formatCIOutput({
+          success: false,
+          command: "share",
+          version: VERSION7,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: 0,
+          error: msg
+        }));
+        process.exit(1);
+      }
+      console.error(`[realitydb] ${msg}`);
+      console.error("Usage: realitydb share <file>");
+      process.exit(1);
+    }
+    const result = await shareRealityPack(filePath);
+    const durationMs = Math.round(performance.now() - start);
+    if (options.ci) {
+      console.log(formatCIOutput({
+        success: true,
+        command: "share",
+        version: VERSION7,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        data: {
+          method: result.method,
+          location: result.location,
+          packName: result.packName,
+          size: result.size,
+          tableCount: result.tableCount,
+          totalRows: result.totalRows
+        }
+      }));
+      return;
+    }
+    console.log("");
+    console.log("RealityDB Share");
+    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(`Pack: ${result.packName} (${result.tableCount} tables, ${result.totalRows} rows, ${result.size})`);
+    console.log("");
+    console.log("Share this file:");
+    console.log(`  File: ${result.location}`);
+    console.log(`  Size: ${result.size}`);
+    console.log("");
+    console.log("The receiver can load it with:");
+    console.log(`  realitydb load ${result.location} --confirm`);
+    console.log("");
+    console.log("Tip: To create the schema first, the receiver can run:");
+    console.log(`  realitydb load ${result.location} --show-ddl`);
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.ci) {
+      console.log(formatCIOutput({
+        success: false,
+        command: "share",
+        version: VERSION7,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Math.round(performance.now() - start),
+        error: message
+      }));
+      process.exit(1);
+    }
+    console.error(`[realitydb] Share failed: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/load.ts
+var VERSION8 = "0.3.0";
+async function loadCommand(filePath, options) {
+  const start = performance.now();
+  try {
+    if (!filePath) {
+      const msg = "Missing file path argument.";
+      if (options.ci) {
+        console.log(formatCIOutput({
+          success: false,
+          command: "load",
+          version: VERSION8,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: 0,
+          error: msg
+        }));
+        process.exit(1);
+      }
+      console.error(`[realitydb] ${msg}`);
+      console.error("Usage: realitydb load <file> --confirm");
+      process.exit(1);
+    }
+    const pack = await loadRealityPack(filePath);
+    if (options.showDdl) {
+      const ddl = pack.metadata.ddl;
+      if (options.ci) {
+        console.log(formatCIOutput({
+          success: true,
+          command: "load",
+          version: VERSION8,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Math.round(performance.now() - start),
+          data: {
+            packName: pack.metadata.name,
+            ddlAvailable: !!ddl,
+            ddl: ddl ?? null
+          }
+        }));
+        return;
+      }
+      if (ddl) {
+        console.log("");
+        console.log("Schema DDL (run this SQL to create tables):");
+        console.log("");
+        console.log(ddl);
+      } else {
+        console.log("");
+        console.log("No DDL available in this Reality Pack.");
+        console.log("This pack was created with pack export (generated data), not capture.");
+        console.log("");
+      }
+      return;
+    }
+    const config = await loadConfig();
+    const masked = maskConnectionString(config.database.connectionString);
+    if (!options.ci) {
+      console.log("");
+      console.log("RealityDB Load");
+      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(`Database: ${masked}`);
+      console.log(`Pack: ${pack.metadata.name} (v${pack.version})`);
+      if (pack.metadata.templateName) {
+        console.log(`Template: ${pack.metadata.templateName}`);
+      }
+      console.log(`Tables: ${pack.metadata.tableCount}`);
+      console.log(`Total rows: ${pack.metadata.totalRows}`);
+      const ddl = pack.metadata.ddl;
+      if (ddl) {
+        console.log("Schema DDL: included");
+      }
+      console.log("");
+    }
+    if (!options.ci && !options.confirm) {
+      console.error("[realitydb] Load requires --confirm flag.");
+      console.error("Hint: This will insert data into your database. Use --confirm to proceed.");
+      console.error("");
+      console.error("To view the schema DDL first:");
+      console.error(`  realitydb load ${filePath} --show-ddl`);
+      process.exit(1);
+    }
+    if (!options.ci) {
+      console.log("Loading...");
+    }
+    const result = await importPack(config, filePath);
+    const durationMs = Math.round(performance.now() - start);
+    if (options.ci) {
+      console.log(formatCIOutput({
+        success: true,
+        command: "load",
+        version: VERSION8,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs,
+        data: {
+          database: masked,
+          packName: pack.metadata.name,
+          totalRows: result.totalRows,
+          tables: result.insertResult.tables.map((t) => ({
+            name: t.tableName,
+            rowsInserted: t.rowsInserted,
+            durationMs: t.durationMs
+          }))
+        }
+      }));
+      return;
+    }
+    for (const tableResult of result.insertResult.tables) {
+      console.log(
+        `  ${tableResult.tableName}: ${tableResult.rowsInserted} rows loaded`
+      );
+    }
+    const totalTime = (result.durationMs / 1e3).toFixed(1);
+    console.log("");
+    console.log(`Load complete. ${result.totalRows} rows in ${totalTime}s`);
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (options.ci) {
+      console.log(formatCIOutput({
+        success: false,
+        command: "load",
+        version: VERSION8,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Math.round(performance.now() - start),
+        error: message
+      }));
+      process.exit(1);
+    }
+    if (message.includes("Config file not found")) {
+      console.error(`[realitydb] ${message}`);
+    } else if (message.includes("Cannot import Reality Pack")) {
+      console.error(`[realitydb] ${message}`);
+      const ddlHint = "Tip: Use --show-ddl to get the schema creation SQL.";
+      console.error(ddlHint);
+    } else if (message.includes("connection") || message.includes("ECONNREFUSED")) {
+      console.error(`[realitydb] Load failed: ${message}`);
+      console.error("Hint: Check that your database is running (e.g. Docker)");
+    } else {
+      console.error(`[realitydb] Load failed: ${message}`);
+    }
+    process.exit(1);
+  }
+}
+
 // src/cli.ts
-var VERSION6 = "0.2.0";
+var VERSION9 = "0.3.0";
 function run(argv) {
   const program2 = new Command();
-  program2.name("realitydb").description("RealityDB \u2014 Developer Reality Platform").version(VERSION6).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.name("realitydb").description("RealityDB \u2014 Developer Reality Platform").version(VERSION9).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("scan").description("Scan database schema").action(async () => {
     const opts = program2.opts();
     await scanCommand({ ci: opts.ci });
@@ -7354,16 +7951,28 @@ function run(argv) {
   });
   program2.command("templates").description("List available domain templates").action(templatesCommand);
   program2.command("scenarios").description("List available scenarios").action(scenariosCommand);
+  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 });
+  });
+  program2.command("share <file>").description("Share a Reality Pack file").action(async (filePath) => {
+    const opts = program2.opts();
+    await shareCommand(filePath, { ci: opts.ci });
+  });
+  program2.command("load <file>").description("Load a Reality Pack into the database").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 });
+  });
   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").action(packExportCommand);
   pack.command("import <file>").description("Import Reality Pack into database").option("--confirm", "Confirm import operation").action(packImportCommand);
   program2.action(() => {
     const opts = program2.opts();
     if (opts.ci) {
-      console.log(JSON.stringify({ name: "realitydb", version: VERSION6 }));
+      console.log(JSON.stringify({ name: "realitydb", version: VERSION9 }));
     } else {
       console.log("");
-      console.log(`RealityDB v${VERSION6} \u2014 Developer Reality Platform`);
+      console.log(`RealityDB v${VERSION9} \u2014 Developer Reality Platform`);
       console.log("Run `realitydb --help` for available commands.");
       console.log("");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "realitydb",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Developer Reality Platform - realistic database environments from your schema",
   "license": "MIT",
   "keywords": [