realitydb 0.2.0 → 0.4.0

package/dist/index.js

@@ -5708,6 +5708,474 @@ var educationTemplate = {
   ])
 };
 
+// ../../packages/templates/dist/domains/fintech.js
+var fintechTemplate = {
+  name: "fintech",
+  version: "1.0",
+  description: "Financial services with accounts, transactions, fraud alerts, and settlements",
+  targetTables: ["accounts", "transactions", "fraud_alerts", "settlements", "chargebacks"],
+  tableConfigs: /* @__PURE__ */ new Map([
+    ["accounts", {
+      tableName: "accounts",
+      matchPattern: ["accounts", "*account*"],
+      columnOverrides: [
+        {
+          columnName: "account_type",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["checking", "savings", "investment", "credit", "business"],
+              weights: [0.35, 0.25, 0.15, 0.15, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "balance_cents",
+          strategy: { kind: "money", options: { min: 0, max: 5e6 } }
+        },
+        {
+          columnName: "currency",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["USD", "EUR", "GBP", "CAD", "JPY"],
+              weights: [0.55, 0.2, 0.1, 0.08, 0.07]
+            }
+          }
+        },
+        {
+          columnName: "status",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["active", "frozen", "closed", "pending_review"],
+              weights: [0.82, 0.05, 0.08, 0.05]
+            }
+          }
+        },
+        {
+          columnName: "owner_name",
+          strategy: { kind: "full_name" }
+        },
+        {
+          columnName: "email",
+          strategy: { kind: "email" }
+        },
+        {
+          columnName: "account_number",
+          strategy: { kind: "text", options: { mode: "short" } }
+        },
+        {
+          columnName: "opened_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }],
+    ["transactions", {
+      tableName: "transactions",
+      matchPattern: ["transactions", "*transaction*", "*transfer*"],
+      columnOverrides: [
+        {
+          columnName: "transaction_type",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["deposit", "withdrawal", "transfer", "payment", "refund", "fee"],
+              weights: [0.25, 0.2, 0.2, 0.2, 0.1, 0.05]
+            }
+          }
+        },
+        {
+          columnName: "amount_cents",
+          strategy: { kind: "money", options: { min: 100, max: 5e5 } }
+        },
+        {
+          columnName: "currency",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["USD", "EUR", "GBP", "CAD", "JPY"],
+              weights: [0.55, 0.2, 0.1, 0.08, 0.07]
+            }
+          }
+        },
+        {
+          columnName: "status",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["completed", "pending", "failed", "reversed", "held"],
+              weights: [0.78, 0.08, 0.05, 0.04, 0.05]
+            }
+          }
+        },
+        {
+          columnName: "description",
+          strategy: { kind: "text", options: { mode: "short" } }
+        },
+        {
+          columnName: "created_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }],
+    ["fraud_alerts", {
+      tableName: "fraud_alerts",
+      matchPattern: ["fraud_alerts", "*fraud*", "*alert*"],
+      columnOverrides: [
+        {
+          columnName: "alert_type",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["unusual_amount", "velocity_check", "geo_mismatch", "duplicate_transaction", "account_takeover"],
+              weights: [0.3, 0.25, 0.2, 0.15, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "severity",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["low", "medium", "high", "critical"],
+              weights: [0.2, 0.4, 0.3, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "status",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["open", "investigating", "resolved_fraud", "resolved_legitimate", "escalated"],
+              weights: [0.25, 0.2, 0.3, 0.15, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "description",
+          strategy: { kind: "text", options: { mode: "short" } }
+        },
+        {
+          columnName: "created_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }],
+    ["settlements", {
+      tableName: "settlements",
+      matchPattern: ["settlements", "*settlement*"],
+      columnOverrides: [
+        {
+          columnName: "settlement_type",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["standard", "expedited", "batch", "real_time"],
+              weights: [0.5, 0.2, 0.2, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "amount_cents",
+          strategy: { kind: "money", options: { min: 100, max: 5e5 } }
+        },
+        {
+          columnName: "status",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["pending", "processing", "completed", "failed"],
+              weights: [0.15, 0.1, 0.7, 0.05]
+            }
+          }
+        },
+        {
+          columnName: "created_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }],
+    ["chargebacks", {
+      tableName: "chargebacks",
+      matchPattern: ["chargebacks", "*chargeback*", "*dispute*"],
+      columnOverrides: [
+        {
+          columnName: "reason",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["unauthorized", "product_not_received", "product_defective", "duplicate_charge", "subscription_canceled", "other"],
+              weights: [0.25, 0.2, 0.15, 0.15, 0.15, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "amount_cents",
+          strategy: { kind: "money", options: { min: 500, max: 2e5 } }
+        },
+        {
+          columnName: "status",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["open", "under_review", "won", "lost", "expired"],
+              weights: [0.2, 0.25, 0.3, 0.15, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "filed_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }]
+  ])
+};
+
+// ../../packages/templates/dist/domains/healthcare.js
+var healthcareTemplate = {
+  name: "healthcare",
+  version: "1.0",
+  description: "Healthcare system with patients, providers, encounters, diagnoses, and billing",
+  targetTables: ["patients", "providers", "encounters", "diagnoses", "billing"],
+  tableConfigs: /* @__PURE__ */ new Map([
+    ["patients", {
+      tableName: "patients",
+      matchPattern: ["patients", "*patient*"],
+      columnOverrides: [
+        {
+          columnName: "first_name",
+          strategy: { kind: "first_name" }
+        },
+        {
+          columnName: "last_name",
+          strategy: { kind: "last_name" }
+        },
+        {
+          columnName: "email",
+          strategy: { kind: "email" }
+        },
+        {
+          columnName: "phone",
+          strategy: { kind: "phone" }
+        },
+        {
+          columnName: "gender",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["Male", "Female", "Non-binary", "Other", "Prefer not to say"],
+              weights: [0.48, 0.48, 0.02, 0.01, 0.01]
+            }
+          }
+        },
+        {
+          columnName: "insurance_provider",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["Blue Cross", "Aetna", "UnitedHealth", "Cigna", "Humana", "Medicare", "Medicaid", "Self-Pay"],
+              weights: [0.18, 0.15, 0.15, 0.12, 0.1, 0.12, 0.1, 0.08]
+            }
+          }
+        },
+        {
+          columnName: "mrn",
+          strategy: { kind: "text", options: { mode: "short" } }
+        },
+        {
+          columnName: "date_of_birth",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        },
+        {
+          columnName: "registered_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }],
+    ["providers", {
+      tableName: "providers",
+      matchPattern: ["providers", "doctors", "physicians", "*provider*"],
+      columnOverrides: [
+        {
+          columnName: "first_name",
+          strategy: { kind: "first_name" }
+        },
+        {
+          columnName: "last_name",
+          strategy: { kind: "last_name" }
+        },
+        {
+          columnName: "email",
+          strategy: { kind: "email" }
+        },
+        {
+          columnName: "specialty",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["Family Medicine", "Internal Medicine", "Pediatrics", "Cardiology", "Orthopedics", "Dermatology", "Neurology", "Psychiatry", "Emergency Medicine", "Radiology"],
+              weights: [0.18, 0.15, 0.12, 0.1, 0.1, 0.08, 0.08, 0.07, 0.07, 0.05]
+            }
+          }
+        },
+        {
+          columnName: "department",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["Primary Care", "Surgery", "Emergency", "Specialty", "Diagnostics"],
+              weights: [0.3, 0.2, 0.15, 0.25, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "npi",
+          strategy: { kind: "text", options: { mode: "short" } }
+        },
+        {
+          columnName: "active",
+          strategy: { kind: "boolean", options: { trueWeight: 0.92 } }
+        }
+      ]
+    }],
+    ["encounters", {
+      tableName: "encounters",
+      matchPattern: ["encounters", "visits", "appointments", "*encounter*", "*visit*"],
+      columnOverrides: [
+        {
+          columnName: "encounter_type",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["office_visit", "emergency", "telehealth", "procedure", "follow_up", "annual_checkup"],
+              weights: [0.35, 0.08, 0.15, 0.12, 0.18, 0.12]
+            }
+          }
+        },
+        {
+          columnName: "status",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["completed", "scheduled", "in_progress", "canceled", "no_show"],
+              weights: [0.55, 0.15, 0.1, 0.1, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "chief_complaint",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["Headache", "Back pain", "Cough", "Chest pain", "Fatigue", "Fever", "Joint pain", "Shortness of breath", "Abdominal pain", "Skin rash", "Dizziness", "Annual checkup"],
+              weights: [0.1, 0.12, 0.1, 0.06, 0.08, 0.08, 0.09, 0.06, 0.08, 0.07, 0.06, 0.1]
+            }
+          }
+        },
+        {
+          columnName: "scheduled_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }],
+    ["diagnoses", {
+      tableName: "diagnoses",
+      matchPattern: ["diagnoses", "*diagnosis*", "*diagnos*"],
+      columnOverrides: [
+        {
+          columnName: "icd_code",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["J06.9", "M54.5", "I10", "E11.9", "J20.9", "R51.9", "M25.50", "Z00.00", "K21.0", "L30.9", "F41.1", "E78.5"],
+              weights: [0.1, 0.1, 0.12, 0.1, 0.08, 0.08, 0.08, 0.08, 0.07, 0.06, 0.07, 0.06]
+            }
+          }
+        },
+        {
+          columnName: "description",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["Acute upper respiratory infection", "Low back pain", "Essential hypertension", "Type 2 diabetes", "Acute bronchitis", "Headache", "Joint pain", "General adult medical exam", "Gastroesophageal reflux", "Dermatitis", "Generalized anxiety disorder", "Hyperlipidemia"],
+              weights: [0.1, 0.1, 0.12, 0.1, 0.08, 0.08, 0.08, 0.08, 0.07, 0.06, 0.07, 0.06]
+            }
+          }
+        },
+        {
+          columnName: "diagnosis_type",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["primary", "secondary", "admitting", "working"],
+              weights: [0.6, 0.25, 0.08, 0.07]
+            }
+          }
+        },
+        {
+          columnName: "diagnosed_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }],
+    ["billing", {
+      tableName: "billing",
+      matchPattern: ["billing", "claims", "charges", "*bill*", "*claim*"],
+      columnOverrides: [
+        {
+          columnName: "cpt_code",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["99213", "99214", "99215", "99203", "99204", "99281", "99282", "99283", "99395", "99396"],
+              weights: [0.25, 0.2, 0.1, 0.1, 0.08, 0.05, 0.05, 0.05, 0.06, 0.06]
+            }
+          }
+        },
+        {
+          columnName: "description",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["Office visit - established, low", "Office visit - established, moderate", "Office visit - established, high", "Office visit - new, low", "Office visit - new, moderate", "ED visit - low", "ED visit - moderate", "ED visit - high", "Preventive visit 18-39", "Preventive visit 40-64"],
+              weights: [0.25, 0.2, 0.1, 0.1, 0.08, 0.05, 0.05, 0.05, 0.06, 0.06]
+            }
+          }
+        },
+        {
+          columnName: "amount_cents",
+          strategy: { kind: "money", options: { min: 5e3, max: 15e4 } }
+        },
+        {
+          columnName: "insurance_covered_cents",
+          strategy: { kind: "money", options: { min: 0, max: 12e4 } }
+        },
+        {
+          columnName: "patient_responsibility_cents",
+          strategy: { kind: "money", options: { min: 0, max: 5e4 } }
+        },
+        {
+          columnName: "status",
+          strategy: {
+            kind: "enum",
+            options: {
+              values: ["paid", "pending", "denied", "appealed", "partially_paid"],
+              weights: [0.5, 0.2, 0.1, 0.05, 0.15]
+            }
+          }
+        },
+        {
+          columnName: "billed_at",
+          strategy: { kind: "timestamp", options: { mode: "past" } }
+        }
+      ]
+    }]
+  ])
+};
+
 // ../../packages/templates/dist/registry.js
 var TemplateRegistry = class {
   templates = /* @__PURE__ */ new Map();
@@ -5763,6 +6231,8 @@ function getDefaultRegistry() {
   registry.register(saasTemplate);
   registry.register(ecommerceTemplate);
   registry.register(educationTemplate);
+  registry.register(fintechTemplate);
+  registry.register(healthcareTemplate);
   return registry;
 }
 
@@ -6150,6 +6620,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();
@@ -6334,10 +6811,89 @@ async function introspectDatabase(pool, schemaName = "public") {
   for (const warning of validation.warnings) {
     console.warn(`[databox] Schema warning: ${warning}`);
   }
-  for (const error of validation.errors) {
-    console.error(`[databox] Schema error: ${error}`);
+  for (const error of validation.errors) {
+    console.error(`[databox] Schema error: ${error}`);
+  }
+  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());
   }
-  return schema;
+  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
@@ -6628,6 +7184,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 +7390,7 @@ function maskConnectionString(connectionString) {
 }
 
 // src/commands/scan.ts
-var VERSION2 = "0.2.0";
+var VERSION2 = "0.4.0";
 async function scanCommand(options) {
   const start = performance.now();
   try {
@@ -6733,7 +7481,7 @@ async function scanCommand(options) {
 }
 
 // src/commands/seed.ts
-var VERSION3 = "0.2.0";
+var VERSION3 = "0.4.0";
 async function seedCommand(options) {
   const start = performance.now();
   try {
@@ -6911,7 +7659,7 @@ async function seedCommand(options) {
 }
 
 // src/commands/reset.ts
-var VERSION4 = "0.2.0";
+var VERSION4 = "0.4.0";
 async function resetCommand(options) {
   const start = performance.now();
   if (!options.ci && !options.confirm) {
@@ -6981,7 +7729,7 @@ async function resetCommand(options) {
 }
 
 // src/commands/export.ts
-var VERSION5 = "0.2.0";
+var VERSION5 = "0.4.0";
 async function exportCommand(options) {
   const start = performance.now();
   try {
@@ -7174,7 +7922,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 +7999,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 +8079,330 @@ async function packImportCommand(filePath, options) {
   }
 }
 
+// src/commands/capture.ts
+var import_promises8 = require("fs/promises");
+var VERSION6 = "0.4.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.4.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.4.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.4.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 +8421,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.4.0",
   "description": "Developer Reality Platform - realistic database environments from your schema",
   "license": "MIT",
   "keywords": [