@treeviz/gedcom-parser 1.0.23 → 2.0.0

package/dist/cli/index.js

@@ -6,6 +6,7 @@ import { Command } from 'commander';
 import { debounce, set, get, uniqBy, unset, difference, intersectionBy, differenceBy } from 'lodash-es';
 import { format, isValid, parse } from 'date-fns';
 import chalk from 'chalk';
+import * as readline from 'readline';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -786,11 +787,30 @@ var Common = class _Common {
     const sour = get(head, "SOUR.value");
     return !!sour?.toLowerCase()?.startsWith("myheritage");
   }
+  /**
+   * Get the source type as a string (for prefixing tree IDs and names)
+   * Returns the detected source type or undefined if unknown
+   */
+  getSourceType() {
+    if (this.isAncestry()) return "Ancestry";
+    if (this.isMyHeritage()) return "MyHeritage";
+    if (this.isFamilySearch()) return "FamilySearch";
+    if (this.isGNO2GED()) return "GNO2GED";
+    if (this.isGenoPro()) return "GenoPro";
+    if (this.isAhnenblatt()) return "Ahnenblatt";
+    if (this.isGeni()) return "Geni";
+    return void 0;
+  }
   isFamilySearch() {
     const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
     const sourName = get(head, "SOUR.NAME.value");
     return sourName === "FamilySearch API";
   }
+  isGNO2GED() {
+    const head = get(this, "HEAD") || get(this.getGedcom(), "HEAD");
+    const sour = get(head, "SOUR.value");
+    return sour === "GNO2GED";
+  }
   getAncestryTreeId() {
     const path = "HEAD.SOUR._TREE.RIN.value";
     return get(this, path) || get(this.getGedcom(), path);
@@ -801,11 +821,34 @@ var Common = class _Common {
   }
   getTreeId() {
     if (this?.isAncestry()) {
-      return this.getAncestryTreeId();
+      const id = this.getAncestryTreeId();
+      if (id !== void 0) return id;
     }
     if (this?.isMyHeritage()) {
-      return this.getMyHeritageTreeId();
+      const id = this.getMyHeritageTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isFamilySearch()) {
+      const id = this.getFamilySearchTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isGNO2GED()) {
+      const id = this.getGNO2GEDTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isAhnenblatt()) {
+      const id = this.getAhnenblattTreeId();
+      if (id !== void 0) return id;
+    }
+    if (this?.isGeni()) {
+      const id = this.getGeniTreeId();
+      if (id !== void 0) return id;
     }
+    if (this?.isGenoPro()) {
+      const id = this.getGenoProTreeId();
+      if (id !== void 0) return id;
+    }
+    return this.getUniversalTreeId();
   }
   getAncestryTreeName() {
     const path = "HEAD.SOUR._TREE.value";
@@ -818,13 +861,146 @@ var Common = class _Common {
       /Exported by MyHeritage.com from (?<tree>.+) in.+$/
     )?.groups?.tree;
   }
+  getFamilySearchTreeId() {
+    const rin = get(this, "HEAD.SOUR._TREE.RIN.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.RIN.value");
+    if (rin) {
+      return rin;
+    }
+    return "familysearch";
+  }
+  getFamilySearchTreeName() {
+    const treeName = get(this, "HEAD.SOUR._TREE.value") || get(this.getGedcom(), "HEAD.SOUR._TREE.value");
+    if (treeName) {
+      return treeName;
+    }
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName || "FamilySearch Import";
+  }
+  getAhnenblattTreeId() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return idMatch[1];
+      }
+    }
+    return void 0;
+  }
+  getAhnenblattTreeName() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  }
+  getGeniTreeId() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return idMatch[1];
+      }
+    }
+    return void 0;
+  }
+  getGeniTreeName() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  }
+  getGenoProTreeId() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return idMatch[1];
+      }
+    }
+    return void 0;
+  }
+  getGenoProTreeName() {
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName?.replace(/\.ged$/i, "").replace(/_/g, " ");
+  }
+  getGNO2GEDTreeId() {
+    const rin = get(this, "HEAD._TREE.RIN.value") || get(this.getGedcom(), "HEAD._TREE.RIN.value");
+    if (rin) {
+      return rin;
+    }
+    return `gno_${this._gedcom?.refcount || "unknown"}`;
+  }
+  getGNO2GEDTreeName() {
+    const treeName = get(this, "HEAD._TREE.value") || get(this.getGedcom(), "HEAD._TREE.value");
+    if (treeName) {
+      return treeName;
+    }
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    return fileName || "GNO2GED Export";
+  }
+  /**
+   * Universal tree ID getter for unknown/unrecognized GEDCOM sources
+   * Tries to extract an ID from various common locations
+   */
+  getUniversalTreeId() {
+    const sourceType = this.getSourceType();
+    const prefix = sourceType ? sourceType.toLowerCase() : "tree";
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const idMatch = fileName.match(/_(\d+)/);
+      if (idMatch) {
+        return `${prefix}_${idMatch[1]}`;
+      }
+    }
+    return `${prefix}_${this._gedcom?.refcount || "unknown"}`;
+  }
+  /**
+   * Universal tree name getter for unknown/unrecognized GEDCOM sources
+   * Tries to extract a name from various common locations
+   */
+  getUniversalTreeName() {
+    const sourceType = this.getSourceType();
+    const prefix = sourceType ? `${sourceType}-` : "";
+    const fileName = get(this, "HEAD.FILE.value") || get(this.getGedcom(), "HEAD.FILE.value");
+    if (fileName) {
+      const cleanName = fileName.replace(/\.ged$/i, "").replace(/_/g, " ");
+      return `${prefix}${cleanName}`;
+    }
+    const sourName = get(this, "HEAD.SOUR.NAME.value") || get(this.getGedcom(), "HEAD.SOUR.NAME.value");
+    if (sourName) {
+      return `${prefix}${sourName}`;
+    }
+    const sourValue = get(this, "HEAD.SOUR.value") || get(this.getGedcom(), "HEAD.SOUR.value");
+    if (sourValue) {
+      return `${prefix}${sourValue}`;
+    }
+    return `${prefix}Unknown Tree`;
+  }
   getTreeName() {
     if (this?.isAncestry()) {
-      return this.getAncestryTreeName();
+      const name = this.getAncestryTreeName();
+      if (name) return name;
     }
     if (this?.isMyHeritage()) {
-      return this.getMyHeritageTreeName();
+      const name = this.getMyHeritageTreeName();
+      if (name) return name;
+    }
+    if (this?.isFamilySearch()) {
+      const name = this.getFamilySearchTreeName();
+      if (name) return name;
+    }
+    if (this?.isGNO2GED()) {
+      const name = this.getGNO2GEDTreeName();
+      if (name) return name;
+    }
+    if (this?.isAhnenblatt()) {
+      const name = this.getAhnenblattTreeName();
+      if (name) return name;
+    }
+    if (this?.isGeni()) {
+      const name = this.getGeniTreeName();
+      if (name) return name;
     }
+    if (this?.isGenoPro()) {
+      const name = this.getGenoProTreeName();
+      if (name) return name;
+    }
+    return this.getUniversalTreeName();
   }
 };
 var createProxy = (target) => {
@@ -962,66 +1138,125 @@ var PARTNER = {
 var SPOUSE = {
   PART: "spouse" /* SPOUSE */
 };
+var getGedcomId = (gedcom) => {
+  if (!gedcom) {
+    return "unknown";
+  }
+  const treeId = gedcom.getTreeId?.() || "";
+  const treeName = gedcom.getTreeName?.() || "";
+  const sanitizedName = treeName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (treeId && sanitizedName) {
+    return `${treeId}_${sanitizedName}`;
+  } else if (treeId) {
+    return treeId;
+  } else if (sanitizedName) {
+    return sanitizedName;
+  }
+  return `gedcom_${gedcom.refcount}`;
+};
 var caches = {
   pathCache: {},
   relativesOnDegreeCache: {},
-  relativesOnLevelCache: {}
+  relativesOnLevelCache: {},
+  profilePictureCache: {}
 };
-var getInstance = getCacheManagerFactory();
-var cacheDbs = {
-  pathCache: getInstance("ftv", "Main", "path", true),
-  relativesOnDegreeCache: getInstance(
-    "ftv",
-    "Main",
-    "path",
-    true
-  ),
-  relativesOnLevelCache: getInstance(
-    "ftv",
-    "Main",
-    "path",
-    true
-  )
+var cacheDbs;
+var getCacheDbs = () => {
+  if (!cacheDbs) {
+    const getInstance = getCacheManagerFactory();
+    cacheDbs = {
+      pathCache: getInstance(
+        "ftv",
+        "Main",
+        "path",
+        true
+      ),
+      relativesOnDegreeCache: getInstance("ftv", "Main", "path", true),
+      relativesOnLevelCache: getInstance(
+        "ftv",
+        "Main",
+        "path",
+        true
+      ),
+      profilePictureCache: getInstance(
+        "ftv",
+        "Main",
+        "images",
+        false
+      )
+    };
+  }
+  return cacheDbs;
 };
-({
+var storeCache = {
+  // NOTE: pathCache, relativesOnLevelCache, and relativesOnDegreeCache are intentionally
+  // kept in memory only. These debounced functions exist to satisfy the type system
+  // but are never called.
   pathCache: debounce((value) => {
     if (value) {
-      cacheDbs.pathCache.setItem(value);
+      getCacheDbs().pathCache.setItem(value);
     }
   }, 50),
   relativesOnLevelCache: debounce((value) => {
     if (value) {
-      cacheDbs.relativesOnLevelCache.setItem(value);
+      getCacheDbs().relativesOnLevelCache.setItem(value);
     }
   }, 50),
   relativesOnDegreeCache: debounce((value) => {
     if (value) {
-      cacheDbs.relativesOnDegreeCache.setItem(value);
+      getCacheDbs().relativesOnDegreeCache.setItem(value);
     }
-  }, 50)
-});
-var relativesCache = (cacheKey) => (key, subKey, value) => {
-  if (!caches[cacheKey]) {
+  }, 50),
+  // profilePictureCache IS persisted to IndexedDB
+  profilePictureCache: debounce((value) => {
+    if (value) {
+      getCacheDbs().profilePictureCache.setItem(value);
+    }
+  }, 100)
+};
+var relativesCache = (cacheKey) => (gedcom, key, subKey, value) => {
+  const gedcomId = getGedcomId(gedcom);
+  const fullKey = `${gedcomId}:${key}`;
+  const cache = caches[cacheKey];
+  if (!cache) {
     caches[cacheKey] = {};
   }
-  if (value && caches[cacheKey]) {
-    if (!caches[cacheKey][key]) {
-      caches[cacheKey][key] = {};
+  if (value) {
+    const typedCache2 = caches[cacheKey];
+    if (!typedCache2[fullKey]) {
+      typedCache2[fullKey] = {};
     }
-    caches[cacheKey][key][subKey] = value;
-    return caches[cacheKey][key][subKey];
+    typedCache2[fullKey][subKey] = value;
+    return typedCache2[fullKey][subKey];
   }
-  return caches[cacheKey]?.[key]?.[subKey];
+  const typedCache = caches[cacheKey];
+  return typedCache?.[fullKey]?.[subKey];
 };
-var pathCache = (key, value) => {
+var pathCache = (gedcom, key, value) => {
+  const gedcomId = getGedcomId(gedcom);
+  const fullKey = `${gedcomId}:${key}`;
   if (!caches.pathCache) {
     caches.pathCache = {};
   }
   if (value && caches.pathCache) {
-    caches.pathCache[key] = value;
-    return caches.pathCache[key];
+    caches.pathCache[fullKey] = value;
+    return caches.pathCache[fullKey];
   }
-  return caches.pathCache?.[key];
+  return caches.pathCache?.[fullKey];
+};
+var profilePictureCache = (gedcom, key, value) => {
+  const gedcomId = getGedcomId(gedcom);
+  const fullKey = `${gedcomId}:${key}`;
+  if (!caches.profilePictureCache) {
+    caches.profilePictureCache = {};
+  }
+  if (value && caches.profilePictureCache) {
+    caches.profilePictureCache[fullKey] = value;
+    storeCache.profilePictureCache(caches.profilePictureCache);
+    return caches.profilePictureCache[fullKey];
+  }
+  const cached = caches.profilePictureCache?.[fullKey];
+  return cached;
 };
 
 // src/utils/get-all-prop.ts
@@ -1927,7 +2162,7 @@ var Indi = class extends Common {
   }
   async ancestryMedia(namespace) {
     const list = {};
-    const objeList = this.get("OBJE")?.toList();
+    const objeList = this.get("OBJE")?.toList().copy();
     const www = this._gedcom?.HEAD?.SOUR?.CORP?.WWW?.value;
     const tree = this.getAncestryTreeId();
     if (objeList) {
@@ -2001,11 +2236,12 @@ var Indi = class extends Common {
     if (!tree) {
       return;
     }
-    const objeList = this.get("OBJE")?.toList();
-    const birthObj = this.get("BIRT.OBJE")?.toList();
-    const deathObj = this.get("DEAT.OBJE")?.toList();
+    const objeList = this.get("OBJE")?.toList().copy();
+    const birthObj = this.get("BIRT.OBJE")?.toList().copy();
+    const deathObj = this.get("DEAT.OBJE")?.toList().copy();
+    objeList?.merge(birthObj).merge(deathObj);
     (this.get("FAMS")?.toValueList().values() ?? []).concat(this.get("FAMC")?.toValueList().values() ?? []).forEach((fam) => {
-      objeList?.merge(birthObj).merge(deathObj).merge(fam?.get("MARR.OBJE"));
+      objeList.merge(fam?.get("MARR.OBJE"));
     });
     objeList?.forEach((o, index) => {
       if (!o) {
@@ -2123,6 +2359,88 @@ var Indi = class extends Common {
       };
     });
   }
+  geniMedia() {
+    const list = {};
+    const objeList = this.get("OBJE")?.toList().copy();
+    const sourList = this.get("SOUR")?.toList().copy();
+    sourList?.forEach((sour) => {
+      const sourObje = sour?.get("OBJE")?.toList();
+      objeList.merge(sourObje);
+    });
+    if (!objeList || objeList.length === 0) {
+      return void 0;
+    }
+    const rfn = this.get("RFN")?.toValue();
+    const geniId = rfn?.replace(/^geni:/, "") || "unknown";
+    objeList.forEach((obje, index) => {
+      if (!obje) {
+        return;
+      }
+      const key = `@O${index}@`;
+      const isPrimary = obje?.get("_PRIM")?.toValue() === "Y";
+      const url = obje?.get("FILE")?.toValue();
+      const title = obje?.get("TITL")?.toValue() ?? "";
+      const type = obje?.get("FORM")?.toValue() ?? "raw";
+      if (url) {
+        const urlMatch = url.match(/\/([^/]+)\?hash=/);
+        const imgId = urlMatch?.[1] || `img-${index}-${Date.now().toString(36)}`;
+        const id = `geni-${geniId}-${imgId}`;
+        list[id] = {
+          isPrimary,
+          key,
+          id,
+          tree: geniId,
+          imgId,
+          person: this.id,
+          title,
+          url,
+          contentType: type,
+          downloadName: `${this.id.replaceAll("@", "")}_${this.toNaturalName()?.replaceAll(" ", "-") || ""}_${(title || key.replaceAll("@", "").toString()).replaceAll(" ", "-")}`
+        };
+      }
+    });
+    return list;
+  }
+  universalMedia() {
+    const list = {};
+    if (!this.id) {
+      return list;
+    }
+    const objeList = this.get("OBJE")?.toList().copy();
+    if (!objeList || objeList.length === 0) {
+      return list;
+    }
+    const rfn = this.get("RFN")?.toValue();
+    const treeId = rfn || "universal";
+    objeList.forEach((obje, index) => {
+      if (!obje) {
+        return;
+      }
+      const key = `@O${index}@`;
+      obje.standardizeMedia();
+      const isPrimary = obje?.get("_PRIM")?.toValue() === "Y";
+      const url = obje?.get("FILE")?.toValue();
+      const title = obje?.get("TITL")?.toValue() ?? "";
+      const type = obje?.get("FORM")?.toValue() ?? "raw";
+      if (url) {
+        const imgId = `media-${index}-${url.split("/").pop()?.split("?")[0]?.substring(0, 20) || Date.now().toString(36)}`;
+        const id = `${treeId}-${this.id}-${imgId}`;
+        list[id] = {
+          isPrimary,
+          key,
+          id,
+          tree: treeId,
+          imgId,
+          person: this.id,
+          title,
+          url,
+          contentType: type,
+          downloadName: `${this.id.replaceAll("@", "")}_${this.toNaturalName()?.replaceAll(" ", "-") || ""}_${(title || key.replaceAll("@", "").toString()).replaceAll(" ", "-")}`
+        };
+      }
+    });
+    return list;
+  }
   async multimedia(namespace) {
     if (this?.isAncestry()) {
       return await this.ancestryMedia(namespace);
@@ -2130,11 +2448,30 @@ var Indi = class extends Common {
     if (this?.isMyHeritage()) {
       return this.myheritageMedia();
     }
-    return void 0;
+    if (this?.isGeni()) {
+      return this.geniMedia();
+    }
+    return this.universalMedia();
   }
   async getProfilePicture(namespace, onlyPrimary = true) {
+    if (!this.id) {
+      return void 0;
+    }
+    const cacheKey = this.id;
+    const cached = profilePictureCache(
+      this._gedcom,
+      cacheKey
+    );
+    if (cached !== void 0) {
+      return cached;
+    }
     const mediaList = await this.multimedia(namespace);
     if (!mediaList) {
+      profilePictureCache(
+        this._gedcom,
+        cacheKey,
+        void 0
+      );
       return void 0;
     }
     const mediaArray = Object.values(mediaList);
@@ -2142,27 +2479,41 @@ var Indi = class extends Common {
       (media) => media.isPrimary && isImageFormat(media.contentType || getFileExtension(media.url))
     );
     if (primaryMedia) {
-      return {
+      const result = {
         file: primaryMedia.url,
         form: primaryMedia.contentType,
         title: primaryMedia.title,
         isPrimary: true
       };
-    }
-    if (!onlyPrimary) {
+      profilePictureCache(this._gedcom, cacheKey, result);
+      return result;
+    }
+    if (onlyPrimary) {
+      profilePictureCache(
+        this._gedcom,
+        cacheKey,
+        void 0
+      );
       return void 0;
     }
     const secondaryMedia = mediaArray.find(
       (media) => isImageFormat(media.contentType || getFileExtension(media.url))
     );
     if (secondaryMedia) {
-      return {
+      const result = {
         file: secondaryMedia.url,
         form: secondaryMedia.contentType,
         title: secondaryMedia.title,
         isPrimary: false
       };
+      profilePictureCache(this._gedcom, cacheKey, result);
+      return result;
     }
+    profilePictureCache(
+      this._gedcom,
+      cacheKey,
+      void 0
+    );
     return void 0;
   }
   link(poolId) {
@@ -2530,7 +2881,7 @@ var Indi = class extends Common {
       return;
     }
     const cacheKey = `${this.id}|${usedIndi.id}`;
-    const cache = pathCache(cacheKey);
+    const cache = pathCache(this._gedcom, cacheKey);
     if (cache) {
       return cache;
     }
@@ -2575,7 +2926,7 @@ var Indi = class extends Common {
         if (breakOnNext) {
           return void 0;
         }
-        pathCache(cacheKey, path2);
+        pathCache(this._gedcom, cacheKey, path2);
         return path2;
       }
       visited.append(indi);
@@ -2745,7 +3096,7 @@ var Indi = class extends Common {
   }
   getRelativesOnDegree(degree = 0) {
     this.id = this.id || `@I${Math.random()}@`;
-    const cache = relativesOnDegreeCache(this.id, degree);
+    const cache = relativesOnDegreeCache(this._gedcom, this.id, degree);
     if (cache) {
       return cache;
     }
@@ -2753,6 +3104,7 @@ var Indi = class extends Common {
     const excludes = persons;
     if (!Math.abs(degree)) {
       return relativesOnDegreeCache(
+        this._gedcom,
         this.id,
         degree,
         persons.except(this)
@@ -2763,11 +3115,11 @@ var Indi = class extends Common {
       excludes.merge(persons);
       persons = this.getRelativesOnLevel(validDegree).getRelativesOnDegree(-validDegree).copy().exclude(excludes);
     }
-    return relativesOnDegreeCache(this.id, degree, persons);
+    return relativesOnDegreeCache(this._gedcom, this.id, degree, persons);
   }
   getRelativesOnLevel(level = 0, filter) {
     this.id = this.id || `@I${Math.random()}@`;
-    const cache = relativesOnLevelCache(this.id, level);
+    const cache = relativesOnLevelCache(this._gedcom, this.id, level);
     if (cache) {
       return cache;
     }
@@ -2778,7 +3130,7 @@ var Indi = class extends Common {
     };
     let families = this.get(config.key)?.toValueList();
     if (!families) {
-      return relativesOnLevelCache(this.id, level, persons);
+      return relativesOnLevelCache(this._gedcom, this.id, level, persons);
     }
     if (filter) {
       families = families.filter(filter);
@@ -2789,7 +3141,12 @@ var Indi = class extends Common {
       persons = this.toFamilies(families).getParents();
     }
     if (level >= -1 && level <= 1) {
-      return relativesOnLevelCache(this.id, level, persons.except(this));
+      return relativesOnLevelCache(
+        this._gedcom,
+        this.id,
+        level,
+        persons.except(this)
+      );
     }
     for (let i = 1; i < Math.abs(level); i++) {
       if (config.isAscendant) {
@@ -2798,7 +3155,12 @@ var Indi = class extends Common {
         persons = persons.getParents();
       }
     }
-    return relativesOnLevelCache(this.id, level, persons.except(this));
+    return relativesOnLevelCache(
+      this._gedcom,
+      this.id,
+      level,
+      persons.except(this)
+    );
   }
   getAscendants(level = 0, filter) {
     if (!level) {
@@ -2837,7 +3199,12 @@ var Indi = class extends Common {
       }
       currentGen++;
       generations[currentGen] = descentants;
-      relativesOnLevelCache(this.id, -currentGen, descentants);
+      relativesOnLevelCache(
+        this._gedcom,
+        this.id,
+        -currentGen,
+        descentants
+      );
       descentants && relatives.merge(descentants);
     }
     return { relatives, generations };
@@ -2870,7 +3237,7 @@ var Indi = class extends Common {
       }
       currentGen++;
       generations[currentGen] = parents;
-      relativesOnLevelCache(this.id, currentGen, parents);
+      relativesOnLevelCache(this._gedcom, this.id, currentGen, parents);
       parents && relatives.merge(parents);
     }
     return { relatives, generations };
@@ -5881,7 +6248,7 @@ var Families = class _Families extends List {
 
 // package.json
 var package_default = {
-  version: "1.0.23"};
+  version: "2.0.0"};
 
 // src/utils/get-product-details.ts
 var isDevelopment = () => {
@@ -6872,7 +7239,7 @@ var GedcomTree = {
     return this.parseHierarchy(content, options);
   },
   parseHierarchy: function(content, options) {
-    const { settings } = options ?? {};
+    const { settings, filename = "" } = options ?? {};
     const { linkedPersons = "skip", linkingKey } = settings ?? {};
     const gedcom = createGedCom();
     gedcom.removeValue();
@@ -6907,6 +7274,25 @@ var GedcomTree = {
       if (lineMatch) {
         const lineIndent = Number(lineMatch?.groups?.indent ?? 0);
         const lineValue = lineMatch?.groups?.value ?? "";
+        const lineType = lineMatch?.groups?.type ?? "";
+        const linesAcc = acc;
+        if (lineIndent === 0 && lineType === "HEAD") {
+          acc.push(line);
+          linesAcc._inHead = true;
+          linesAcc._hasFile = false;
+          return acc;
+        }
+        if (lineIndent === 0 && linesAcc._inHead) {
+          if (filename && !linesAcc._hasFile) {
+            acc.push(`1 FILE ${filename}`);
+          }
+          linesAcc._inHead = false;
+          acc.push(line);
+          return acc;
+        }
+        if (linesAcc._inHead && lineIndent === 1 && lineType === "FILE") {
+          linesAcc._hasFile = true;
+        }
         if (lineIndent > 0 && lineIndent > prevLineIndent && lineValue && isId(lineValue)) {
           const refLines = lineValue.split(/,\s*/).map((id) => line.replace(lineValue, id));
           if (refLines.length > 1) {
@@ -7121,12 +7507,6 @@ function formatDate(date) {
   }
   return chalk.white(date);
 }
-function formatPlace(place) {
-  if (!place) {
-    return chalk.gray("(unknown)");
-  }
-  return chalk.white(place);
-}
 function formatName(name) {
   if (!name) {
     return chalk.gray("(unnamed)");
@@ -7309,102 +7689,327 @@ function registerExtractCommand(program2) {
 }
 
 // src/cli/commands/find.ts
-function registerFindCommand(program2) {
-  program2.command("find <file> [query]").description("Find individuals in a GEDCOM file").option("--id <id>", "Find by GEDCOM ID").option("--name <name>", "Find by name (substring search)").option("--birth-year <year>", "Filter by birth year").option("--death-year <year>", "Filter by death year").option("-j, --json", "Output in JSON format").action((file, query, options) => {
-    try {
-      const content = readGedcomFile(file);
-      const { gedcom: tree } = parser_default.parse(content);
-      const individuals = tree.indis();
-      const results = [];
-      individuals.forEach((indi) => {
-        let matches = true;
-        if (options.id && indi.id !== options.id) {
-          matches = false;
-        }
-        if ((options.name || query) && matches) {
-          const searchName = (options.name || query || "").toLowerCase();
-          const name = cleanGedcomName(indi.NAME?.toValue()).toLowerCase();
-          if (!name.includes(searchName)) {
-            matches = false;
-          }
+function findIndividuals(tree, options) {
+  const individuals = tree.indis();
+  const results = [];
+  individuals.forEach((indi) => {
+    let matches = true;
+    if (options.id && indi.id !== options.id) {
+      matches = false;
+    }
+    if ((options.name || options.query) && matches) {
+      const searchName = (options.name || options.query || "").toLowerCase();
+      const name = cleanGedcomName(indi?.toNaturalName()).toLowerCase();
+      if (!name.includes(searchName)) {
+        matches = false;
+      }
+    }
+    if (options.birthYear && matches) {
+      const year = options.birthYear;
+      const birthDate = indi.BIRT?.DATE?.toValue();
+      if (!birthDate?.includes(String(year))) {
+        matches = false;
+      }
+    }
+    if (options.deathYear && matches) {
+      const year = options.deathYear;
+      const deathDate = indi.DEAT?.DATE?.toValue();
+      if (!deathDate?.includes(String(year))) {
+        matches = false;
+      }
+    }
+    if (matches) {
+      results.push(indi);
+    }
+  });
+  return results;
+}
+function formatFindResults(results, json = false) {
+  if (json) {
+    const jsonResults = results.map((indi) => ({
+      id: indi.id,
+      name: cleanGedcomName(indi.NAME?.toValue()),
+      birthDate: indi.BIRT?.DATE?.toValue() || null,
+      birthPlace: indi.BIRT?.PLAC?.value || null,
+      deathDate: indi.DEAT?.DATE?.toValue() || null,
+      deathPlace: indi.DEAT?.PLAC?.value || null,
+      sex: indi.SEX?.value || null
+    }));
+    console.log(
+      formatJson({ count: jsonResults.length, individuals: jsonResults })
+    );
+  } else {
+    if (results.length === 0) {
+      console.log(
+        formatWarning("No individuals found matching the criteria")
+      );
+    } else {
+      console.log(
+        formatHeader(`Found ${results.length} individual(s)
+`)
+      );
+      results.forEach((indi) => {
+        const name = cleanGedcomName(indi.NAME?.toValue());
+        const birthDate = indi.BIRT?.DATE?.toValue();
+        const deathDate = indi.DEAT?.DATE?.toValue();
+        const lifespan = formatLifespan(birthDate, deathDate);
+        console.log(
+          formatListItem(
+            `${formatId(indi.id)} ${formatName(name)} ${lifespan}`
+          )
+        );
+        const birthPlace = indi.BIRT?.PLAC?.value;
+        if (birthPlace) {
+          console.log(
+            formatListItem(
+              `Birth: ${formatDate(birthDate)} in ${birthPlace}`,
+              1
+            )
+          );
         }
-        if (options.birthYear && matches) {
-          const year = options.birthYear;
-          const birthDate = indi.BIRT?.DATE?.toValue();
-          if (!birthDate?.includes(String(year))) {
-            matches = false;
-          }
+        const deathPlace = indi.DEAT?.PLAC?.value;
+        if (deathPlace) {
+          console.log(
+            formatListItem(
+              `Death: ${formatDate(deathDate)} in ${deathPlace}`,
+              1
+            )
+          );
         }
-        if (options.deathYear && matches) {
-          const year = options.deathYear;
-          const deathDate = indi.DEAT?.DATE?.toValue();
-          if (!deathDate?.includes(String(year))) {
-            matches = false;
+        console.log();
+      });
+    }
+  }
+}
+function registerFindCommand(program2) {
+  program2.command("find <file> [query]").description("Find individuals in a GEDCOM file").option("--id <id>", "Find by GEDCOM ID").option("--name <name>", "Find by name (substring search)").option("--birth-year <year>", "Filter by birth year").option("--death-year <year>", "Filter by death year").option("-j, --json", "Output in JSON format").action(
+    (file, query, options) => {
+      try {
+        const content = readGedcomFile(file);
+        const { gedcom: tree } = parser_default.parse(content);
+        const results = findIndividuals(tree, {
+          ...options,
+          query
+        });
+        formatFindResults(results, options.json);
+      } catch (error) {
+        handleError(error, "Failed to search GEDCOM file");
+      }
+    }
+  );
+}
+
+// src/cli/commands/get.ts
+function getValueByPath(record, path) {
+  return record.get(path);
+}
+function formatOutput(value, options) {
+  if (value === void 0 || value === null) {
+    return "(not found)";
+  }
+  if (value instanceof List) {
+    if (options.json) {
+      const items2 = [];
+      value.forEach((item) => {
+        if (item) {
+          try {
+            items2.push(JSON.parse(item.toJson()));
+          } catch {
+            items2.push(item.toValue());
           }
         }
-        if (matches) {
-          results.push(indi);
+      });
+      return JSON.stringify(items2, null, 2);
+    }
+    if (options.raw) {
+      const items2 = [];
+      value.forEach((item) => {
+        if (item) {
+          items2.push(item.toGedcom());
         }
       });
-      if (options.json) {
-        const jsonResults = results.map((indi) => ({
-          id: indi.id,
-          name: cleanGedcomName(indi.NAME?.toValue()),
-          birthDate: indi.BIRT?.DATE?.toValue() || null,
-          birthPlace: indi.BIRT?.PLAC?.value || null,
-          deathDate: indi.DEAT?.DATE?.toValue() || null,
-          deathPlace: indi.DEAT?.PLAC?.value || null,
-          sex: indi.SEX?.value || null
-        }));
-        console.log(formatJson({ count: jsonResults.length, individuals: jsonResults }));
-      } else {
-        if (results.length === 0) {
-          console.log(formatWarning("No individuals found matching the criteria"));
-        } else {
-          console.log(formatHeader(`Found ${results.length} individual(s)
-`));
-          results.forEach((indi) => {
-            const name = cleanGedcomName(indi.NAME?.toValue());
-            const birthDate = indi.BIRT?.DATE?.toValue();
-            const deathDate = indi.DEAT?.DATE?.toValue();
-            const lifespan = formatLifespan(birthDate, deathDate);
-            console.log(
-              formatListItem(
-                `${formatId(indi.id)} ${formatName(name)} ${lifespan}`
-              )
-            );
-            const birthPlace = indi.BIRT?.PLAC?.value;
-            if (birthPlace) {
-              console.log(formatListItem(`Birth: ${formatDate(birthDate)} in ${birthPlace}`, 1));
-            }
-            const deathPlace = indi.DEAT?.PLAC?.value;
-            if (deathPlace) {
-              console.log(formatListItem(`Death: ${formatDate(deathDate)} in ${deathPlace}`, 1));
-            }
-            console.log();
-          });
+      return items2.join("\n");
+    }
+    const items = [];
+    let index = 0;
+    value.forEach((item) => {
+      if (item) {
+        const exportedValue = item.exportValue();
+        items.push(
+          `[${index}] ${exportedValue || item.toValue() || "(empty)"}`
+        );
+      }
+      index++;
+    });
+    return items.join("\n");
+  }
+  if (value instanceof Common) {
+    if (options.json) {
+      return value.toJson();
+    }
+    if (options.raw) {
+      return value.toValue() || "(empty)";
+    }
+    return value.exportValue() || value.toValue() || "(empty)";
+  }
+  return String(value);
+}
+function getValue(tree, id, path, json = false, raw = false) {
+  let record = null;
+  let recordType = "";
+  if (id.startsWith("@I")) {
+    record = tree.indi(id);
+    recordType = "Individual";
+  } else if (id.startsWith("@F")) {
+    record = tree.fam(id);
+    recordType = "Family";
+  } else if (id.startsWith("@S")) {
+    record = tree.sour(id);
+    recordType = "Source";
+  } else {
+    record = tree.indi(id);
+    recordType = "Individual";
+  }
+  if (!record) {
+    throw new Error(`Record ${id} not found`);
+  }
+  if (!path) {
+    if (json) {
+      const simplified = {
+        id: record.id || id,
+        type: recordType
+      };
+      if (recordType === "Individual") {
+        if (record.NAME) {
+          simplified.name = record.toNaturalName();
+        }
+        if (record.BIRT) {
+          simplified.birth = {
+            date: record.BIRT.DATE?.toValue(),
+            place: record.BIRT.PLAC?.value
+          };
+        }
+        if (record.DEAT) {
+          simplified.death = {
+            date: record.DEAT.DATE?.toValue(),
+            place: record.DEAT.PLAC?.value
+          };
+        }
+        if (record.SEX) {
+          simplified.sex = record.SEX.value;
         }
       }
-    } catch (error) {
-      handleError(error, "Failed to search GEDCOM file");
+      return formatJson(simplified);
+    } else {
+      let result = `${recordType}: ${id}`;
+      if (recordType === "Individual" && record.NAME) {
+        result += `
+Name: ${record.NAME.toValue()}`;
+      }
+      return result;
     }
-  });
+  }
+  const value = getValueByPath(record, path);
+  if (value === void 0) {
+    throw new Error(`Path "${path}" not found in ${recordType} ${id}`);
+  }
+  return formatOutput(value, { json, raw });
 }
-
-// src/cli/commands/info.ts
-function registerInfoCommand(program2) {
-  program2.command("info <file>").description("Display basic information about a GEDCOM file").option("-j, --json", "Output in JSON format").option("-v, --verbose", "Show detailed information").action((file, options) => {
+function registerGetCommand(program2) {
+  program2.command("get <file> <id>").description("Get a value from a GEDCOM record").option(
+    "-p, --path <path>",
+    'Dot-separated path to the value (e.g., "BIRT.PLAC", "NAME")'
+  ).option("-j, --json", "Output in JSON format").option("-r, --raw", "Output raw value only (no formatting)").action((file, id, options) => {
     try {
       const content = readGedcomFile(file);
       const { gedcom: tree } = parser_default.parse(content);
-      const individuals = tree.indis();
-      const families = tree.fams();
-      const sources = tree.sours();
-      const repos = tree.repos();
-      const objes = tree.objes();
-      const submitters = tree.subms();
-      const header = tree.HEAD;
-      const version = header?.GEDC?.VERS?.value || "Unknown";
+      let record = null;
+      let recordType = "";
+      if (id.startsWith("@I")) {
+        record = tree.indi(id);
+        recordType = "Individual";
+      } else if (id.startsWith("@F")) {
+        record = tree.fam(id);
+        recordType = "Family";
+      } else if (id.startsWith("@S")) {
+        record = tree.sour(id);
+        recordType = "Source";
+      } else if (id.startsWith("@N")) {
+        record = tree.note(id);
+        recordType = "Note";
+      } else {
+        record = tree.indi(id);
+        recordType = "Individual";
+      }
+      if (!record) {
+        console.error(formatError(`Record ${id} not found`));
+        process.exit(1);
+      }
+      if (!options.path) {
+        if (options.json) {
+          const simplified = {
+            id: record.id || id,
+            type: recordType
+          };
+          if (recordType === "Individual") {
+            if (record.NAME) {
+              simplified.name = record.NAME.toValue();
+            }
+            if (record.BIRT) {
+              simplified.birth = {
+                date: record.BIRT.DATE?.toValue(),
+                place: record.BIRT.PLAC?.value
+              };
+            }
+            if (record.DEAT) {
+              simplified.death = {
+                date: record.DEAT.DATE?.toValue(),
+                place: record.DEAT.PLAC?.value
+              };
+            }
+            if (record.SEX) {
+              simplified.sex = record.SEX.value;
+            }
+          }
+          console.log(formatJson(simplified));
+        } else {
+          console.log(`${recordType}: ${id}`);
+          if (recordType === "Individual" && record.NAME) {
+            console.log(`Name: ${record.NAME.toValue()}`);
+          }
+        }
+        return;
+      }
+      const value = getValueByPath(record, options.path);
+      if (value === void 0) {
+        console.error(
+          formatError(
+            `Path "${options.path}" not found in ${recordType} ${id}`
+          )
+        );
+        process.exit(1);
+      }
+      console.log(formatOutput(value, options));
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/cli/commands/info.ts
+function registerInfoCommand(program2) {
+  program2.command("info <file>").description("Display basic information about a GEDCOM file").option("-j, --json", "Output in JSON format").option("-v, --verbose", "Show detailed information").action((file, options) => {
+    try {
+      const content = readGedcomFile(file);
+      const { gedcom: tree } = parser_default.parse(content);
+      const individuals = tree.indis();
+      const families = tree.fams();
+      const sources = tree.sours();
+      const repos = tree.repos();
+      const objes = tree.objes();
+      const submitters = tree.subms();
+      const header = tree.HEAD;
+      const version = header?.GEDC?.VERS?.value || "Unknown";
       const info = {
         file,
         version,
@@ -7514,6 +8119,862 @@ function registerMergeCommand(program2) {
     }
   });
 }
+
+// src/cli/commands/select.ts
+function selectIndividual(tree, input, searchResults) {
+  if (/^\d+$/.test(input) && searchResults && searchResults.length > 0) {
+    const index = parseInt(input) - 1;
+    if (index >= 0 && index < searchResults.length) {
+      return searchResults[index];
+    }
+    return void 0;
+  }
+  return tree.indi(input);
+}
+function formatSelectResult(individual, input) {
+  if (individual) {
+    const name = cleanGedcomName(individual.NAME?.toValue());
+    console.log(
+      formatSuccess(
+        `Selected: ${formatId(individual.id)} ${formatName(name)}`
+      )
+    );
+  } else {
+    console.log(formatError(`Individual ${input} not found`));
+  }
+}
+function registerSelectCommand(program2) {
+  program2.command("select <file> <id>").description("Select an individual by ID").action((file, id) => {
+    try {
+      const content = readGedcomFile(file);
+      const { gedcom: tree } = parser_default.parse(content);
+      const individual = selectIndividual(tree, id);
+      formatSelectResult(individual, id);
+      if (!individual) {
+        process.exit(1);
+      }
+    } catch (error) {
+      handleError(error, "Failed to select individual");
+    }
+  });
+}
+
+// src/cli/commands/show.ts
+function showIndividual(tree, individual) {
+  const name = cleanGedcomName(individual.NAME?.toValue());
+  console.log(
+    formatHeader(`
+${formatId(individual.id)} ${formatName(name)}`)
+  );
+  console.log("");
+  if (individual.SEX?.value) {
+    console.log(formatListItem(`Sex: ${individual.SEX.value}`));
+  }
+  if (individual.BIRT) {
+    const date = individual.BIRT.DATE?.toValue();
+    const place = individual.BIRT.PLAC?.value;
+    console.log(
+      formatListItem(
+        `Birth: ${date || "?"}${place ? ` at ${place}` : ""}`
+      )
+    );
+  }
+  if (individual.DEAT) {
+    const date = individual.DEAT.DATE?.toValue();
+    const place = individual.DEAT.PLAC?.value;
+    console.log(
+      formatListItem(
+        `Death: ${date || "?"}${place ? ` at ${place}` : ""}`
+      )
+    );
+  }
+  const parentFams = individual.FAMC;
+  if (parentFams) {
+    const parentList = parentFams instanceof List ? parentFams.values() : [parentFams];
+    console.log(formatListItem("\nParents:"));
+    parentList.forEach((famRef) => {
+      if (famRef) {
+        const fam = tree.fam(famRef.value);
+        if (fam) {
+          const father = fam.HUSB ? tree.indi(fam.HUSB.value) : null;
+          const mother = fam.WIFE ? tree.indi(fam.WIFE.value) : null;
+          if (father) {
+            const fatherName = cleanGedcomName(
+              father.NAME?.toValue()
+            );
+            console.log(
+              formatListItem(
+                `  ${formatId(father.id)} ${formatName(fatherName)}`
+              )
+            );
+          }
+          if (mother) {
+            const motherName = cleanGedcomName(
+              mother.NAME?.toValue()
+            );
+            console.log(
+              formatListItem(
+                `  ${formatId(mother.id)} ${formatName(motherName)}`
+              )
+            );
+          }
+        }
+      }
+    });
+  }
+  const spouseFams = individual.FAMS;
+  if (spouseFams) {
+    const famList = spouseFams instanceof List ? spouseFams.values() : [spouseFams];
+    console.log(formatListItem("\nSpouses:"));
+    famList.forEach((famRef) => {
+      if (famRef) {
+        const fam = tree.fam(famRef.value);
+        if (fam) {
+          const spouseRef = fam.HUSB?.value === individual.id ? fam.WIFE : fam.HUSB;
+          if (spouseRef) {
+            const spouse = tree.indi(spouseRef.value);
+            if (spouse) {
+              const spouseName = cleanGedcomName(
+                spouse.NAME?.toValue()
+              );
+              console.log(
+                formatListItem(
+                  `  ${formatId(spouse.id)} ${formatName(spouseName)}`
+                )
+              );
+            }
+          }
+        }
+      }
+    });
+  }
+  if (spouseFams) {
+    const famList = spouseFams instanceof List ? spouseFams.values() : [spouseFams];
+    let hasChildren = false;
+    famList.forEach((famRef) => {
+      if (famRef) {
+        const fam = tree.fam(famRef.value);
+        if (fam && fam.CHIL) {
+          if (!hasChildren) {
+            console.log(formatListItem("\nChildren:"));
+            hasChildren = true;
+          }
+          const children = fam.CHIL instanceof List ? fam.CHIL.values() : [fam.CHIL];
+          children.forEach((childRef) => {
+            if (childRef) {
+              const child = tree.indi(childRef.value);
+              if (child) {
+                const childName = cleanGedcomName(
+                  child.NAME?.toValue()
+                );
+                console.log(
+                  formatListItem(
+                    `  ${formatId(child.id)} ${formatName(childName)}`
+                  )
+                );
+              }
+            }
+          });
+        }
+      }
+    });
+  }
+  console.log("");
+}
+function registerShowCommand(program2) {
+  program2.command("show <file> <id>").description("Display detailed information about an individual").action((file, id) => {
+    try {
+      const content = readGedcomFile(file);
+      const { gedcom: tree } = parser_default.parse(content);
+      const individual = tree.indi(id);
+      if (!individual) {
+        console.error(formatError(`Individual ${id} not found`));
+        process.exit(1);
+      }
+      showIndividual(tree, individual);
+    } catch (error) {
+      handleError(error, "Failed to show individual");
+    }
+  });
+}
+
+// src/cli/commands/stats.ts
+function displayStats(tree, json = false) {
+  const stats = tree.stats();
+  if (json) {
+    console.log(formatJson(stats));
+  } else {
+    console.log(formatHeader("GEDCOM File Statistics\n"));
+    console.log(formatLabel("Total Individuals"));
+    console.log(`  ${formatCount(stats.totalIndividuals)}`);
+    console.log(formatLabel("Total Families"));
+    console.log(`  ${formatCount(stats.totalFamilies)}`);
+    console.log();
+    console.log(formatLabel("By Gender"));
+    console.log(`  Males: ${formatCount(stats.byGender.males)}`);
+    console.log(`  Females: ${formatCount(stats.byGender.females)}`);
+    console.log(`  Unknown: ${formatCount(stats.byGender.unknown)}`);
+    console.log();
+    if (stats.dateRange.earliest && stats.dateRange.latest) {
+      console.log(formatLabel("Date Range"));
+      console.log(
+        `  ${stats.dateRange.earliest} - ${stats.dateRange.latest}`
+      );
+      console.log();
+    }
+    if (stats.averageLifespan) {
+      console.log(formatLabel("Average Lifespan"));
+      console.log(`  ${stats.averageLifespan.toFixed(1)} years`);
+      console.log();
+    }
+    if (stats.topSurnames.length > 0) {
+      console.log(formatLabel("Most Common Surnames"));
+      stats.topSurnames.forEach(({ surname, count }) => {
+        console.log(`  ${surname}: ${formatCount(count)}`);
+      });
+      console.log();
+    }
+    if (stats.topBirthPlaces.length > 0) {
+      console.log(formatLabel("Most Common Birth Places"));
+      stats.topBirthPlaces.slice(0, 5).forEach(({ place, count }) => {
+        console.log(`  ${place}: ${formatCount(count)}`);
+      });
+    }
+  }
+}
+function registerStatsCommand(program2) {
+  program2.command("stats <file>").description("Generate statistics about a GEDCOM file").option("-j, --json", "Output in JSON format").action((file, options) => {
+    try {
+      const content = readGedcomFile(file);
+      const { gedcom: tree } = parser_default.parse(content);
+      displayStats(tree, options.json);
+    } catch (error) {
+      handleError(error, "Failed to generate statistics");
+    }
+  });
+}
+
+// src/cli/repl.ts
+function parseArgs(line) {
+  const args = [];
+  let current = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuotes) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    args.push(current);
+  }
+  return args;
+}
+var GedcomRepl = class {
+  constructor(tree) {
+    this.context = { tree };
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: chalk.blue("gedcom> ")
+    });
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.rl.on("line", (line) => {
+      this.handleCommand(line.trim());
+    });
+    this.rl.on("close", () => {
+      console.log("\nGoodbye!");
+      process.exit(0);
+    });
+  }
+  handleCommand(line) {
+    if (!line) {
+      this.rl.prompt();
+      return;
+    }
+    const args = parseArgs(line);
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    switch (command.toLowerCase()) {
+      case "help":
+        this.showHelp(commandArgs[0]);
+        break;
+      case "stats":
+        displayStats(this.context.tree, commandArgs.includes("--json"));
+        break;
+      case "find":
+        this.handleFind(commandArgs);
+        break;
+      case "select":
+        this.handleSelect(commandArgs);
+        break;
+      case "show":
+        this.handleShow(commandArgs);
+        break;
+      case "get":
+        this.handleGet(commandArgs);
+        break;
+      case "relatives":
+        this.handleRelatives(commandArgs);
+        break;
+      case "validate":
+        this.handleValidate(commandArgs);
+        break;
+      case "clear":
+        console.clear();
+        break;
+      case "exit":
+      case "quit":
+        this.rl.close();
+        return;
+      default:
+        console.log(formatError(`Unknown command: ${command}`));
+        console.log('Type "help" for available commands');
+    }
+    this.rl.prompt();
+  }
+  showHelp(command) {
+    if (command) {
+      switch (command.toLowerCase()) {
+        case "stats":
+          console.log(formatHeader("\nstats"));
+          console.log("Show GEDCOM file statistics\n");
+          console.log("Usage: stats [--json]");
+          console.log("\nOptions:");
+          console.log("  --json    Output in JSON format");
+          break;
+        case "find":
+          console.log(formatHeader("\nfind"));
+          console.log("Search for individuals in the tree\n");
+          console.log("Usage: find <query> [options]");
+          console.log("\nArguments:");
+          console.log("  <query>   Search query (name or ID)");
+          console.log("\nOptions:");
+          console.log("  --birth-year <year>   Filter by birth year");
+          console.log("  --death-year <year>   Filter by death year");
+          console.log(
+            "  --json                Output in JSON format"
+          );
+          break;
+        case "select":
+          console.log(formatHeader("\nselect"));
+          console.log("Select an individual by ID or index\n");
+          console.log("Usage: select <id|index>");
+          console.log("\nArguments:");
+          console.log(
+            "  <id|index>   Individual ID (e.g., @I123@) or search result index (e.g., 1)"
+          );
+          break;
+        case "show":
+          console.log(formatHeader("\nshow"));
+          console.log(
+            "Show detailed information about an individual\n"
+          );
+          console.log("Usage: show [id]");
+          console.log("\nArguments:");
+          console.log(
+            "  [id]   Optional individual ID. If not provided, shows currently selected person"
+          );
+          break;
+        case "get":
+          console.log(formatHeader("\nget"));
+          console.log("Get a value from a GEDCOM record\n");
+          console.log("Usage: get [id] [options]");
+          console.log("\nArguments:");
+          console.log(
+            "  [id]   Record ID (e.g., @I123@, @F456@). If not provided, uses selected person"
+          );
+          console.log("\nOptions:");
+          console.log(
+            '  --path, -p <path>   Dot-separated path (e.g., "BIRT.PLAC", "NAME")'
+          );
+          console.log("  --json, -j          Output in JSON format");
+          console.log(
+            "  --raw, -r           Output raw value only (no formatting)"
+          );
+          console.log("\nExamples:");
+          console.log('  get --path "BIRT.PLAC"');
+          console.log('  get @I123@ --path "NAME"');
+          console.log("  get @I123@ --json");
+          break;
+        case "relatives":
+          console.log(formatHeader("\nrelatives"));
+          console.log(
+            "Get ancestors and/or descendants of the selected individual\n"
+          );
+          console.log("Usage: relatives [options]");
+          console.log("\nOptions:");
+          console.log("  --ancestors, -a     Include ancestors");
+          console.log("  --descendants, -d   Include descendants");
+          console.log(
+            "  --tree, -t          Include both ancestors and descendants"
+          );
+          console.log(
+            "  --depth <n>         Limit depth (generations, default: 999)"
+          );
+          console.log("  --json, -j          Output in JSON format");
+          console.log(
+            "\nNote: You must select an individual first using 'select'"
+          );
+          console.log("\nExamples:");
+          console.log("  relatives --ancestors");
+          console.log("  relatives --descendants --depth 3");
+          console.log("  relatives --tree --json");
+          break;
+        case "validate":
+          console.log(formatHeader("\nvalidate"));
+          console.log("Validate the GEDCOM file\n");
+          console.log("Usage: validate [options]");
+          console.log("\nOptions:");
+          console.log("  --json, -j    Output in JSON format");
+          console.log("  --strict, -s  Enable strict validation");
+          console.log("\nExamples:");
+          console.log("  validate");
+          console.log("  validate --strict --json");
+          break;
+        case "clear":
+          console.log(formatHeader("\nclear"));
+          console.log("Clear the screen\n");
+          console.log("Usage: clear");
+          break;
+        case "exit":
+        case "quit":
+          console.log(formatHeader("\nexit"));
+          console.log("Exit the REPL\n");
+          console.log("Usage: exit");
+          console.log("Alias: quit");
+          break;
+        default:
+          console.log(formatError(`Unknown command: ${command}`));
+          console.log('Type "help" for available commands');
+      }
+      console.log("");
+      return;
+    }
+    console.log(formatHeader("\nAvailable Commands:"));
+    console.log("");
+    console.log(
+      chalk.cyan("  stats [--json]") + "              - Show tree statistics"
+    );
+    console.log(
+      chalk.cyan("  find <query> [options]") + "     - Search for individuals"
+    );
+    console.log(
+      chalk.cyan("  select <id|index>") + "          - Select an individual"
+    );
+    console.log(
+      chalk.cyan("  show [id]") + "                  - Show details (current or specified person)"
+    );
+    console.log(
+      chalk.cyan("  get [id] [options]") + "         - Get a value from a record"
+    );
+    console.log(
+      chalk.cyan("  relatives [options]") + "        - Get ancestors/descendants of selected person"
+    );
+    console.log(
+      chalk.cyan("  validate [options]") + "         - Validate the GEDCOM file"
+    );
+    console.log(
+      chalk.cyan("  clear") + "                      - Clear screen"
+    );
+    console.log(
+      chalk.cyan("  help [command]") + "             - Show this help or help for a specific command"
+    );
+    console.log(
+      chalk.cyan("  exit") + "                       - Exit REPL"
+    );
+    console.log("");
+  }
+  handleFind(args) {
+    if (args.length === 0) {
+      console.log(formatError("Usage: find <query> [options]"));
+      console.log('Type "help find" for more information');
+      return;
+    }
+    const isJson = args.includes("--json");
+    let birthYear;
+    let deathYear;
+    const birthYearIndex = args.indexOf("--birth-year");
+    if (birthYearIndex !== -1 && birthYearIndex + 1 < args.length) {
+      birthYear = args[birthYearIndex + 1];
+    }
+    const deathYearIndex = args.indexOf("--death-year");
+    if (deathYearIndex !== -1 && deathYearIndex + 1 < args.length) {
+      deathYear = args[deathYearIndex + 1];
+    }
+    const query = args.filter((a, i) => {
+      if (a.startsWith("--")) return false;
+      if (i > 0 && args[i - 1].startsWith("--")) return false;
+      return true;
+    }).join(" ");
+    const results = findIndividuals(this.context.tree, {
+      query: query || void 0,
+      birthYear,
+      deathYear
+    });
+    this.context.searchResults = results;
+    formatFindResults(results, isJson);
+    if (results.length > 0 && !isJson) {
+      console.log(
+        chalk.dim(
+          '\nTip: Use "select <number>" to select an individual from results'
+        )
+      );
+    }
+  }
+  handleSelect(args) {
+    if (args.length === 0) {
+      console.log(formatError("Usage: select <id|index>"));
+      return;
+    }
+    const input = args[0];
+    const individual = selectIndividual(
+      this.context.tree,
+      input,
+      this.context.searchResults
+    );
+    formatSelectResult(individual, input);
+    if (individual) {
+      this.context.selectedPerson = individual;
+      console.log(chalk.dim('Tip: Use "show" to see details'));
+    }
+  }
+  handleShow(args) {
+    let individual;
+    if (args.length > 0) {
+      individual = this.context.tree.indi(args[0]);
+      if (!individual) {
+        console.log(formatError(`Individual ${args[0]} not found`));
+        return;
+      }
+    } else {
+      individual = this.context.selectedPerson;
+      if (!individual) {
+        console.log(
+          formatError(
+            'No person selected. Use "select <id>" first or "show <id>"'
+          )
+        );
+        return;
+      }
+    }
+    showIndividual(this.context.tree, individual);
+  }
+  handleGet(args) {
+    if (args.length === 0) {
+      console.log(
+        formatError("Usage: get <id> [--path <path>] [--json] [--raw]")
+      );
+      console.log('Type "help get" for more information');
+      return;
+    }
+    let id;
+    let path;
+    let json = false;
+    let raw = false;
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "--path" || arg === "-p") {
+        if (i + 1 < args.length) {
+          path = args[i + 1];
+          i++;
+        }
+      } else if (arg === "--json" || arg === "-j") {
+        json = true;
+      } else if (arg === "--raw" || arg === "-r") {
+        raw = true;
+      } else if (!arg.startsWith("-") && !id) {
+        id = arg;
+      }
+    }
+    if (!id) {
+      if (this.context.selectedPerson) {
+        id = this.context.selectedPerson.id;
+      } else {
+        console.log(
+          formatError("No ID specified and no person selected")
+        );
+        return;
+      }
+    }
+    try {
+      const result = getValue(this.context.tree, id, path, json, raw);
+      console.log(result);
+    } catch (error) {
+      console.log(formatError(error.message));
+    }
+  }
+  handleRelatives(args) {
+    if (!this.context.selectedPerson) {
+      console.log(
+        formatError('No person selected. Use "select <id>" first')
+      );
+      return;
+    }
+    const isJson = args.includes("--json") || args.includes("-j");
+    const includeAncestors = args.includes("--ancestors") || args.includes("-a") || args.includes("--tree") || args.includes("-t");
+    const includeDescendants = args.includes("--descendants") || args.includes("-d") || args.includes("--tree") || args.includes("-t");
+    if (!includeAncestors && !includeDescendants) {
+      console.log(
+        formatError(
+          "Must specify --ancestors, --descendants, or --tree"
+        )
+      );
+      console.log('Type "help relatives" for more information');
+      return;
+    }
+    let maxDepth = 999;
+    const depthIndex = args.findIndex((arg) => arg === "--depth");
+    if (depthIndex !== -1 && depthIndex + 1 < args.length) {
+      maxDepth = parseInt(args[depthIndex + 1], 10);
+      if (isNaN(maxDepth) || maxDepth < 1) {
+        console.log(formatError("Invalid depth value"));
+        return;
+      }
+    }
+    const individual = this.context.selectedPerson;
+    const relatives = /* @__PURE__ */ new Set();
+    relatives.add(individual.id);
+    if (includeAncestors) {
+      const getAncestors = (indi, depth) => {
+        if (depth > maxDepth) return;
+        const parents = indi.getParents();
+        parents?.forEach((parent) => {
+          relatives.add(parent.id);
+          getAncestors(parent, depth + 1);
+        });
+      };
+      getAncestors(individual, 1);
+    }
+    if (includeDescendants) {
+      const getDescendants = (indi, depth) => {
+        if (depth > maxDepth) return;
+        const children = indi.getChildren();
+        children?.forEach((child) => {
+          relatives.add(child.id);
+          getDescendants(child, depth + 1);
+        });
+      };
+      getDescendants(individual, 1);
+    }
+    const allRelatives = Array.from(relatives).map((relId) => this.context.tree.indi(relId)).filter((indi) => indi !== null);
+    if (isJson) {
+      const jsonData = allRelatives.map((indi) => ({
+        id: indi.id,
+        name: cleanGedcomName(indi.NAME?.toValue()),
+        birthDate: indi.BIRT?.DATE?.toValue() || null,
+        deathDate: indi.DEAT?.DATE?.toValue() || null
+      }));
+      console.log(
+        formatJson({ count: jsonData.length, individuals: jsonData })
+      );
+    } else {
+      console.log(
+        formatHeader(`Found ${allRelatives.length} relative(s)
+`)
+      );
+      allRelatives.forEach((indi) => {
+        const name = cleanGedcomName(indi.NAME?.toValue());
+        const lifespan = formatLifespan(
+          indi.BIRT?.DATE?.toValue(),
+          indi.DEAT?.DATE?.toValue()
+        );
+        console.log(
+          formatListItem(
+            `${formatId(indi.id)} ${formatName(name)} ${lifespan}`
+          )
+        );
+      });
+    }
+  }
+  handleValidate(args) {
+    const isJson = args.includes("--json") || args.includes("-j");
+    const isStrict = args.includes("--strict") || args.includes("-s");
+    const errors = [];
+    const warnings = [];
+    const header = this.context.tree.HEAD;
+    const version = header?.GEDC?.VERS?.value || "Unknown";
+    const individuals = this.context.tree.indis();
+    const families = this.context.tree.fams();
+    individuals.forEach((indi) => {
+      if (!indi.NAME?.toValue()) {
+        warnings.push(`Individual ${indi.id} is missing a name`);
+      }
+    });
+    let missingBirthDates = 0;
+    individuals.forEach((indi) => {
+      if (!indi.BIRT?.DATE?.toValue()) {
+        missingBirthDates++;
+      }
+    });
+    let missingDeathDates = 0;
+    individuals.forEach((indi) => {
+      if (indi.DEAT && !indi.DEAT.DATE?.toValue()) {
+        missingDeathDates++;
+      }
+    });
+    const seenIds = /* @__PURE__ */ new Set();
+    const duplicateIds = [];
+    const checkDuplicates = (item) => {
+      if (seenIds.has(item.id)) {
+        duplicateIds.push(item.id);
+        errors.push(`Duplicate ID found: ${item.id}`);
+      }
+      seenIds.add(item.id);
+    };
+    individuals.forEach(checkDuplicates);
+    families.forEach(checkDuplicates);
+    families.forEach((fam) => {
+      const husb = fam.HUSB?.value;
+      const wife = fam.WIFE?.value;
+      if (!husb && !wife) {
+        warnings.push(`Family ${fam.id} has no husband or wife`);
+      }
+      if (husb && !this.context.tree.indi(husb)) {
+        errors.push(
+          `Family ${fam.id} references non-existent husband ${husb}`
+        );
+      }
+      if (wife && !this.context.tree.indi(wife)) {
+        errors.push(
+          `Family ${fam.id} references non-existent wife ${wife}`
+        );
+      }
+    });
+    if (isStrict) {
+      individuals.forEach((indi) => {
+        const birthDate = indi.BIRT?.DATE?.toValue();
+        const deathDate = indi.DEAT?.DATE?.toValue();
+        if (birthDate && birthDate.includes("INVALID")) {
+          errors.push(`Invalid birth date format for ${indi.id}`);
+        }
+        if (deathDate && deathDate.includes("INVALID")) {
+          errors.push(`Invalid death date format for ${indi.id}`);
+        }
+      });
+    }
+    const result = {
+      valid: errors.length === 0,
+      version,
+      errors,
+      warnings
+    };
+    if (isJson) {
+      console.log(formatJson(result));
+    } else {
+      if (result.valid) {
+        console.log(formatSuccess(`Valid GEDCOM ${version} file`));
+      } else {
+        console.log(
+          formatError(
+            `Invalid GEDCOM file - ${errors.length} error(s) found`
+          )
+        );
+      }
+      console.log();
+      console.log(formatHeader("Validation Summary"));
+      console.log(
+        `${formatError("Errors:")} ${formatCount(errors.length)}`
+      );
+      console.log(
+        `${formatWarning("Warnings:")} ${formatCount(warnings.length)}`
+      );
+      if (errors.length > 0) {
+        console.log();
+        console.log(formatHeader("Errors"));
+        errors.slice(0, 10).forEach((error) => {
+          console.log(formatListItem(formatError(error)));
+        });
+        if (errors.length > 10) {
+          console.log(
+            formatListItem(
+              `... and ${errors.length - 10} more errors`
+            )
+          );
+        }
+      }
+      if (warnings.length > 0) {
+        console.log();
+        console.log(formatHeader("Warnings"));
+        if (missingBirthDates > 0) {
+          console.log(
+            formatListItem(
+              formatWarning(
+                `Missing birth dates: ${missingBirthDates} individuals`
+              )
+            )
+          );
+        }
+        if (missingDeathDates > 0) {
+          console.log(
+            formatListItem(
+              formatWarning(
+                `Missing death dates: ${missingDeathDates} individuals`
+              )
+            )
+          );
+        }
+        if (duplicateIds.length > 0) {
+          console.log(
+            formatListItem(
+              formatWarning(
+                `Duplicate IDs: ${duplicateIds.length}`
+              )
+            )
+          );
+        }
+        const otherWarnings = warnings.filter(
+          (w) => !w.includes("birth") && !w.includes("death")
+        );
+        otherWarnings.slice(0, 5).forEach((warning) => {
+          console.log(formatListItem(formatWarning(warning)));
+        });
+        if (otherWarnings.length > 5) {
+          console.log(
+            formatListItem(
+              `... and ${otherWarnings.length - 5} more warnings`
+            )
+          );
+        }
+      }
+    }
+  }
+  start() {
+    console.log(formatHeader("GEDCOM Interactive Explorer"));
+    console.log("");
+    console.log(chalk.dim('Type "help" for available commands'));
+    console.log("");
+    this.rl.prompt();
+  }
+};
+
+// src/cli/commands/open.ts
+function registerOpenCommand(program2) {
+  program2.command("open <file>").description("Open GEDCOM file in interactive mode").action((file) => {
+    try {
+      const content = readGedcomFile(file);
+      const { gedcom: tree } = parser_default.parse(content);
+      const repl = new GedcomRepl(tree);
+      repl.start();
+    } catch (error) {
+      handleError(error, "Failed to open GEDCOM file");
+    }
+  });
+}
 function registerRelativesCommand(program2) {
   program2.command("relatives <file> <id>").description("Get ancestors and/or descendants of an individual").option("-a, --ancestors", "Include ancestors").option("-d, --descendants", "Include descendants").option("-t, --tree", "Include both ancestors and descendants").option("--depth <n>", "Limit depth (generations)", "999").option("-o, --output <file>", "Save to new GEDCOM file").option("-j, --json", "Output in JSON format").action((file, id, options) => {
     try {
@@ -7598,242 +9059,6 @@ function createSubsetGedcom(tree, individuals) {
   return lines.join("\n");
 }
 
-// src/cli/commands/show.ts
-function registerShowCommand(program2) {
-  program2.command("show <file> <id>").description("Display detailed information about an individual").option("-j, --json", "Output in JSON format").option("-f, --format <format>", "Output format: text, json, markdown", "text").option("--include-events", "Include all life events").option("--include-sources", "Include sources").action((file, id, options) => {
-    try {
-      const content = readGedcomFile(file);
-      const { gedcom: tree } = parser_default.parse(content);
-      const individual = tree.indi(id);
-      if (!individual) {
-        console.error(formatError(`Individual ${id} not found`));
-        process.exit(1);
-      }
-      const name = cleanGedcomName(individual.NAME?.toValue());
-      const birthDate = individual.BIRT?.DATE?.toValue();
-      const birthPlace = individual.BIRT?.PLAC?.value;
-      const deathDate = individual.DEAT?.DATE?.toValue();
-      const deathPlace = individual.DEAT?.PLAC?.value;
-      const sex = individual.SEX?.value;
-      const parents = individual.getParents();
-      const father = parents?.find((p) => p.SEX?.value === "M");
-      const mother = parents?.find((p) => p.SEX?.value === "F");
-      const spouses = individual.getSpouses();
-      const children = individual.getChildren();
-      if (options.json || options.format === "json") {
-        const jsonData = {
-          id: individual.id,
-          name,
-          sex,
-          birth: {
-            date: birthDate || null,
-            place: birthPlace || null
-          },
-          death: {
-            date: deathDate || null,
-            place: deathPlace || null
-          },
-          parents: {
-            father: father ? {
-              id: father.id,
-              name: cleanGedcomName(father.NAME?.toValue())
-            } : null,
-            mother: mother ? {
-              id: mother.id,
-              name: cleanGedcomName(mother.NAME?.toValue())
-            } : null
-          },
-          spouses: spouses.map((spouse) => ({
-            id: spouse.id,
-            name: cleanGedcomName(spouse.NAME?.toValue()),
-            birthDate: spouse.BIRT?.DATE?.toValue() || null,
-            deathDate: spouse.DEAT?.DATE?.toValue() || null
-          })),
-          children: children.map((child) => ({
-            id: child.id,
-            name: cleanGedcomName(child.NAME?.toValue()),
-            birthDate: child.BIRT?.DATE?.toValue() || null,
-            deathDate: child.DEAT?.DATE?.toValue() || null
-          }))
-        };
-        console.log(formatJson(jsonData));
-      } else if (options.format === "markdown") {
-        console.log(`# ${formatId(individual.id)} ${name}
-`);
-        if (birthDate || birthPlace) {
-          console.log(`**Born:** ${birthDate || "?"}`);
-          if (birthPlace) console.log(`  in ${birthPlace}`);
-          console.log();
-        }
-        if (deathDate || deathPlace) {
-          console.log(`**Died:** ${deathDate || "?"}`);
-          if (deathPlace) console.log(`  in ${deathPlace}`);
-          console.log();
-        }
-        if (father || mother) {
-          console.log("## Parents\n");
-          if (father) {
-            const fatherName = cleanGedcomName(father.NAME?.toValue());
-            const fatherLifespan = formatLifespan(
-              father.BIRT?.DATE?.toValue(),
-              father.DEAT?.DATE?.toValue()
-            );
-            console.log(`- **Father:** ${father.id} ${fatherName} ${fatherLifespan}`);
-          }
-          if (mother) {
-            const motherName = cleanGedcomName(mother.NAME?.toValue());
-            const motherLifespan = formatLifespan(
-              mother.BIRT?.DATE?.toValue(),
-              mother.DEAT?.DATE?.toValue()
-            );
-            console.log(`- **Mother:** ${mother.id} ${motherName} ${motherLifespan}`);
-          }
-          console.log();
-        }
-        if (spouses.length > 0) {
-          console.log("## Spouses\n");
-          spouses.forEach((spouse) => {
-            const spouseName = cleanGedcomName(spouse.NAME?.toValue());
-            const spouseLifespan = formatLifespan(
-              spouse.BIRT?.DATE?.toValue(),
-              spouse.DEAT?.DATE?.toValue()
-            );
-            console.log(`- ${spouse.id} ${spouseName} ${spouseLifespan}`);
-          });
-          console.log();
-        }
-        if (children.length > 0) {
-          console.log("## Children\n");
-          children.forEach((child) => {
-            const childName = cleanGedcomName(child.NAME?.toValue());
-            const childLifespan = formatLifespan(
-              child.BIRT?.DATE?.toValue(),
-              child.DEAT?.DATE?.toValue()
-            );
-            console.log(`- ${child.id} ${childName} ${childLifespan}`);
-          });
-          console.log();
-        }
-      } else {
-        console.log(formatHeader(`${formatId(individual.id)} ${formatName(name)}
-`));
-        if (sex) {
-          console.log(`${formatLabel("Sex")} ${formatValue(sex === "M" ? "Male" : sex === "F" ? "Female" : sex)}`);
-        }
-        if (birthDate || birthPlace) {
-          console.log(`${formatLabel("Born")} ${formatDate(birthDate)}`);
-          if (birthPlace) {
-            console.log(`${formatLabel("Birth Place")} ${formatPlace(birthPlace)}`);
-          }
-        }
-        if (deathDate || deathPlace) {
-          console.log(`${formatLabel("Died")} ${formatDate(deathDate)}`);
-          if (deathPlace) {
-            console.log(`${formatLabel("Death Place")} ${formatPlace(deathPlace)}`);
-          }
-        }
-        if (father || mother) {
-          console.log();
-          console.log(formatHeader("Parents"));
-          if (father) {
-            const fatherName = cleanGedcomName(father.NAME?.toValue());
-            const fatherLifespan = formatLifespan(
-              father.BIRT?.DATE?.toValue(),
-              father.DEAT?.DATE?.toValue()
-            );
-            console.log(formatListItem(`${formatLabel("Father")} ${formatId(father.id)} ${formatName(fatherName)} ${fatherLifespan}`));
-          }
-          if (mother) {
-            const motherName = cleanGedcomName(mother.NAME?.toValue());
-            const motherLifespan = formatLifespan(
-              mother.BIRT?.DATE?.toValue(),
-              mother.DEAT?.DATE?.toValue()
-            );
-            console.log(formatListItem(`${formatLabel("Mother")} ${formatId(mother.id)} ${formatName(motherName)} ${motherLifespan}`));
-          }
-        }
-        if (spouses.length > 0) {
-          console.log();
-          console.log(formatHeader("Spouses"));
-          spouses.forEach((spouse) => {
-            const spouseName = cleanGedcomName(spouse.NAME?.toValue());
-            const spouseLifespan = formatLifespan(
-              spouse.BIRT?.DATE?.toValue(),
-              spouse.DEAT?.DATE?.toValue()
-            );
-            console.log(formatListItem(`${formatId(spouse.id)} ${formatName(spouseName)} ${spouseLifespan}`));
-          });
-        }
-        if (children.length > 0) {
-          console.log();
-          console.log(formatHeader("Children"));
-          children.forEach((child) => {
-            const childName = cleanGedcomName(child.NAME?.toValue());
-            const childLifespan = formatLifespan(
-              child.BIRT?.DATE?.toValue(),
-              child.DEAT?.DATE?.toValue()
-            );
-            console.log(formatListItem(`${formatId(child.id)} ${formatName(childName)} ${childLifespan}`));
-          });
-        }
-      }
-    } catch (error) {
-      handleError(error, "Failed to show individual details");
-    }
-  });
-}
-
-// src/cli/commands/stats.ts
-function registerStatsCommand(program2) {
-  program2.command("stats <file>").description("Generate statistics about a GEDCOM file").option("-j, --json", "Output in JSON format").action((file, options) => {
-    try {
-      const content = readGedcomFile(file);
-      const { gedcom: tree } = parser_default.parse(content);
-      const stats = tree.stats();
-      if (options.json) {
-        console.log(formatJson(stats));
-      } else {
-        console.log(formatHeader("GEDCOM File Statistics\n"));
-        console.log(formatLabel("Total Individuals"));
-        console.log(`  ${formatCount(stats.totalIndividuals)}`);
-        console.log(formatLabel("Total Families"));
-        console.log(`  ${formatCount(stats.totalFamilies)}`);
-        console.log();
-        console.log(formatLabel("By Gender"));
-        console.log(`  Males: ${formatCount(stats.byGender.males)}`);
-        console.log(`  Females: ${formatCount(stats.byGender.females)}`);
-        console.log(`  Unknown: ${formatCount(stats.byGender.unknown)}`);
-        console.log();
-        if (stats.dateRange.earliest && stats.dateRange.latest) {
-          console.log(formatLabel("Date Range"));
-          console.log(`  ${stats.dateRange.earliest} - ${stats.dateRange.latest}`);
-          console.log();
-        }
-        if (stats.averageLifespan) {
-          console.log(formatLabel("Average Lifespan"));
-          console.log(`  ${stats.averageLifespan.toFixed(1)} years`);
-          console.log();
-        }
-        if (stats.topSurnames.length > 0) {
-          console.log(formatLabel("Most Common Surnames"));
-          stats.topSurnames.forEach(({ surname, count }) => {
-            console.log(`  ${surname}: ${formatCount(count)}`);
-          });
-          console.log();
-        }
-        if (stats.topBirthPlaces.length > 0) {
-          console.log(formatLabel("Most Common Birth Places"));
-          stats.topBirthPlaces.slice(0, 5).forEach(({ place, count }) => {
-            console.log(`  ${place}: ${formatCount(count)}`);
-          });
-        }
-      }
-    } catch (error) {
-      handleError(error, "Failed to generate statistics");
-    }
-  });
-}
-
 // src/cli/commands/validate.ts
 function registerValidateCommand(program2) {
   program2.command("validate <file>").description("Validate a GEDCOM file").option("-j, --json", "Output in JSON format").option("-s, --strict", "Enable strict validation").option("--fix", "Attempt to fix common issues (not implemented)").action((file, options) => {
@@ -7970,6 +9195,7 @@ var program = new Command();
 program.name("gedcom-parser").description("CLI tool for parsing and manipulating GEDCOM files").version(packageJson.version);
 registerInfoCommand(program);
 registerFindCommand(program);
+registerSelectCommand(program);
 registerShowCommand(program);
 registerValidateCommand(program);
 registerRelativesCommand(program);
@@ -7977,6 +9203,8 @@ registerExtractCommand(program);
 registerStatsCommand(program);
 registerMergeCommand(program);
 registerConvertCommand(program);
+registerGetCommand(program);
+registerOpenCommand(program);
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
   program.outputHelp();