strom-research 1.16.0-beta.2 → 1.16.0-beta.3

package/CHANGELOG.cs.md

@@ -20,6 +20,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   jako jméno po sňatku, nikdy jako přejmenování ani jako další tvar rodného jména; stejné příjmení je stejné jméno,
   ať s ním jde jakékoli křestní. Když se v aplikaci změní nebo smaže, staré zmizí tam, kde ho daly jen úpravy
   v aplikaci; jméno doložené záznamem zůstává. `strom intake` čte `_MARNM` jiných programů jako jméno po sňatku.
+  Výzkum založený dřív z takového rodokmenu (MyHeritage, Legacy, PAF) je doplní ze souboru, který má uložený:
+  `strom input names I…` je ukáže, `--apply` přidá jen tato jména s citací importu, `--undo` je vezme zpět.
 - **Linie výzkumu.** České texty všude říkají „linie výzkumu“, nikde už „směry“.
 
 ## 1.15.0

package/CHANGELOG.de.md

@@ -21,7 +21,10 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Strom-App zurückschickt, kommt als Name nach der Heirat an, nie als Umbenennung oder als weitere Form des
   Geburtsnamens; derselbe Familienname ist derselbe Name, mit welchem Vornamen auch immer. In der App geändert oder
   entfernt, geht der alte dort, wo ihn nur Änderungen in der App gaben; einer, den ein Eintrag belegt, bleibt.
-  `strom intake` liest `_MARNM` anderer Programme als Namen nach der Heirat.
+  `strom intake` liest `_MARNM` anderer Programme als Namen nach der Heirat. Eine Forschung, die früher aus so einem
+  Stammbaum begonnen wurde (MyHeritage, Legacy, PAF), bekommt sie aus der Datei, die sie aufbewahrt:
+  `strom input names I…` zeigt sie, `--apply` fügt nur diese Namen hinzu, mit dem Import als Quelle, `--undo` nimmt
+  sie zurück.
 - **Forschungslinien auf Tschechisch.** Die tschechischen Texte sagen jetzt überall „linie výzkumu“ (Forschungslinien).
 
 ## 1.15.0

package/CHANGELOG.md

@@ -20,6 +20,8 @@ The changes of each version in short. The full notes and the install lines are o
   comes in as a name of the married kind, never as a rename or another form of the birth name; the same surname is
   the same name whatever first name goes with it. Changed or taken off in the app, the old one goes where only edits
   in the app gave it; one a record gives stays. `strom intake` reads `_MARNM` of other programs as a married name.
+  A research started earlier from such a family tree (MyHeritage, Legacy, PAF) gets them from the file it keeps:
+  `strom input names I…` shows them, `--apply` adds only these names, citing the import, `--undo` takes them back.
 - **Lines of research in Czech.** The Czech texts say „linie výzkumu“ (lines of research) everywhere now.
 
 ## 1.15.0

package/dist/commands/intake.js

@@ -9,11 +9,11 @@ import path from "node:path";
 import { register } from "../cli/registry.js";
 import { lines, moreLine, paginate, table, truncate } from "../cli/format.js";
 import { notFound, UsageError } from "../core/errors.js";
-import { likelyDuplicates } from "../core/people.js";
 import { collectFiles, fileSha256, inputPath, MAX_IN_TREE, mimeOf, storeShared } from "../core/media.js";
 import { create, normId, requireRecord, update } from "../core/records.js";
 import { phrase } from "../core/phrases.js";
-import { importGedcom, importStromJson, isStromJson } from "../core/import.js";
+import { addMarriedNames, importedTree, importGedcom, importStromJson, isStromJson, marriedNamesPlan, undoMarriedNames } from "../core/import.js";
+import { gedcomName, likelyDuplicates } from "../core/people.js";
 import { decodeText, safeFolderName } from "../core/text.js";
 import { amendInput, checkOriginalMeta } from "../core/originals.js";
 import { batchStatus, closeBatch, listBatches, readBatch } from "../core/batches.js";
@@ -153,6 +153,13 @@ register({
                         skipped++;
                         if (forTask)
                             handed.push(known.get(sha));
+                        // a family tree imported before strom read its married names (_MARNM): said how they come in
+                        const had = tree.get(known.get(sha));
+                        if (!quiet && had && !importedTree(had)) {
+                            const missing = marriedNamesPlan(tree, had, decodeText(fs.readFileSync(file))).add.length;
+                            if (missing)
+                                report.push(`  ${had.id}: ${missing} married name(s) it gives were left out when it was imported → strom input names ${had.id}`);
+                        }
                         continue;
                     }
                     const size = fs.statSync(file).size;
@@ -315,6 +322,73 @@ register({
         const got = tree.withTreeLock(() => amendInput(tree, id, { persons, note: typeof opts.note === "string" ? opts.note : undefined }));
         return { text: tree.written.length ? lines(...tree.written.map((o) => o.summary)) : `${id}: nothing new`, data: got };
     },
+}, {
+    path: ["input", "names"],
+    summary: "The married names (_MARNM) of a family tree imported before strom read them: shown, --apply adds them",
+    group: "inputs",
+    tree: true,
+    writes: true,
+    description: "strom before 1.16 left out the married names other programs write as _MARNM (MyHeritage, Legacy, PAF). This reads\n" +
+        "the file the research was started from again — the input it keeps — and finds the people imported from it by the\n" +
+        "IDs the import kept (nobody else). Only names of the married kind are added, beside the name each person is shown\n" +
+        "by, citing the import's source; a person who has the name already stays as they are; people of the file not in the\n" +
+        "research are only listed. Without --apply only shown; --apply is one commit; --undo takes back what it added.\n" +
+        "Another export of the tree (another file) is not paired: give the input the research has (strom input list).",
+    args: [{ name: "input", description: "the imported family tree: its input (I…), or the same file", required: true }],
+    options: [
+        { name: "apply", type: "boolean", description: "add them (without: only show)" },
+        { name: "undo", type: "boolean", description: "take back the married names it added from this input" },
+    ],
+    examples: ["strom input names I0004", "strom input names ~/Downloads/rodokmen.ged --apply", "strom input names I0004 --undo"],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const arg = args[0];
+        const inputs = tree.list("input");
+        let input = /^I?\d+$/i.test(arg.trim()) ? inputs.find((i) => i.id === normId(arg, "input")) : undefined;
+        if (!input) {
+            const p = ctx.resolvePath(arg);
+            if (!fs.existsSync(p) || !fs.statSync(p).isFile()) {
+                // an input's ID this research does not have (a file of that name neither)
+                if (/^I?\d+$/i.test(arg.trim()))
+                    throw new UsageError(`no input ${normId(arg, "input")} in this research`, { hint: "strom input list", code: "input.names.missing", params: { input: normId(arg, "input") } });
+                throw notFound(arg);
+            }
+            const sha = fileSha256(p);
+            input = inputs.find((i) => i.sha === sha);
+            if (!input)
+                throw new UsageError(`${ctx.display(p)} is not a family tree this research was started from (another file, another export)`, {
+                    hint: "the research keeps the file it imported: strom input list — then strom input names I…",
+                    code: "input.names.other-file",
+                });
+        }
+        const why = importedTree(input);
+        if (why)
+            throw new UsageError(why, { hint: "strom input list — a family tree imported from GEDCOM (kind tree)", code: "input.names.not-imported", params: { input: input.id } });
+        const name = (id) => {
+            const p = tree.get(id);
+            return p?.names[0] ? gedcomName(p.names[0]).replace(/\//g, "").replace(/\s+/g, " ").trim() : id;
+        };
+        if (opts.undo) {
+            const gone = undoMarriedNames(tree, input);
+            return {
+                text: gone.length ? lines(...gone.map((g) => `  ${g.person} ${name(g.person)}: − ${gedcomName(g.name)}`), `${gone.length} married name(s) from ${input.id} taken back`) : `${input.id}: no married name of it to take back`,
+                data: { input: input.id, undone: gone.map((g) => ({ person: g.person, name: gedcomName(g.name) })) },
+            };
+        }
+        const file = inputPath(tree, input);
+        if (!file || !fs.existsSync(file))
+            throw new UsageError(`the file of ${input.id} is not here (${input.file ?? "none"})`, { hint: `strom input show ${input.id}`, code: "input.names.no-file", params: { input: input.id } });
+        const plan = marriedNamesPlan(tree, input, decodeText(fs.readFileSync(file)));
+        if (opts.apply && plan.add.length)
+            addMarriedNames(tree, plan);
+        const done = !!opts.apply && !tree.dryRun;
+        const text = lines(`${input.id} ${input.name}: ${plan.add.length} married name(s) ${done ? "added" : "to add"}, ${plan.have.length} already there, ${plan.unpaired.length} person(s) of the file not in the research`, ...plan.add.map((a) => `  ${a.person} ${name(a.person)}: + ${gedcomName(a.name)} (married)`), plan.unpaired.length ? "not in the research (nothing added):" : undefined, ...plan.unpaired.map((u) => `  ${u.xref} ${u.name.replace(/\//g, "").replace(/\s+/g, " ").trim()}: ${u.married.map(gedcomName).join(", ")}`), plan.add.length && !opts.apply ? `\nadd them: strom input names ${input.id} --apply` : undefined, done && plan.add.length ? `take them back: strom input names ${input.id} --undo` : undefined);
+        const row = (a) => ({ person: a.person, xref: a.xref, name: gedcomName(a.name) });
+        return {
+            text,
+            data: { input: input.id, source: plan.source, applied: done, add: plan.add.map(row), have: plan.have.map(row), unpaired: plan.unpaired.map((u) => ({ xref: u.xref, name: u.name, married: u.married.map(gedcomName) })) },
+        };
+    },
 }, {
     path: ["input", "batch"],
     summary: "Batches of material the Strom app sent: how many files, how far they are sorted",

package/dist/core/import.js

@@ -11,7 +11,8 @@ import { foldText } from "./text.js";
 import { roleWord } from "./roles.js";
 import { validateRecord } from "./validate.js";
 import { normalizeDate } from "./gdate.js";
-import { appNoSurname, cleanTitle, noName, notAName, parseName, sameName, surnameAfterGiven, withoutTitles } from "./people.js";
+import { appNoSurname, cleanTitle, gedcomName, noName, notAName, parseName, sameName, surnameAfterGiven, withoutTitles } from "./people.js";
+import { update } from "./records.js";
 import { now } from "./tree.js";
 import { appUnknownIsNoSurname, appWritesSexUnknown } from "./stromapp.js";
 import { children, parseGedcomText, val } from "../gedcom/parse.js";
@@ -197,6 +198,11 @@ export function marnmNames(r, givenOf) {
         add(m.value, names[0] ? givenOf(names[0]) : "");
     return out;
 }
+/** The married names (_MARNM) of a person of a file as strom intake takes them: with the given name of their NAME (none for what stands in place of a name). */
+function importedMarnm(r, file) {
+    const given = (n) => (notAName(readGedName(n, file).name.given) ? "" : readGedName(n, file).name.given.replace(/\//g, "|"));
+    return marnmNames(r, given);
+}
 export function importGedcom(tree, text, opts) {
     const { records, problems } = parseGedcomText(text);
     /** A file of the Strom app (its HEAD: 1 SOUR STROM): its own ways of writing are read as it means them. */
@@ -370,8 +376,7 @@ export function importGedcom(tree, text, opts) {
             })
                 .map((n) => (n.given || n.surname ? n : { ...n, given: "?", surname: "" }));
             // a married name other programs give apart (_MARNM): a name of the married kind, unless the person has it already
-            const given = (n) => (notAName(readGedName(n, fromApp).name.given) ? "" : readGedName(n, fromApp).name.given.replace(/\//g, "|"));
-            return [...names, ...marnmNames(r, given).filter((m) => !names.some((n) => sameName(n, m)))];
+            return [...names, ...importedMarnm(r, fromApp).filter((m) => !names.some((n) => sameName(n, m)))];
         };
         /** The Strom app keeps what a birth or death entry adds in the person's note ("Úmrtí: Věk: 61 let"): back to the fact; the other lines are returned. */
         const factNotes = (r, personEvents) => {
@@ -532,6 +537,100 @@ export function importGedcom(tree, text, opts) {
  * research's tree coming back"); a file that names no research (the standard file, another program) only where most
  * of the people its IDs name are alike by name — and then each by its name too. Merged since: the one it went into.
  */
+// ── the married names an earlier import left out ─────────────────────────────
+//
+// strom before 1.16 read no _MARNM (MyHeritage, Legacy, PAF): a research started from such a file lacks the names
+// after a marriage. Taken in again from the very file it was started from (its input), by the IDs the import kept
+// (refs gedcom:<sha> + the file's xref) — nobody else, nothing but these names.
+/** Where a married name taken in later cites the import: the person's xref in the file and the tag. */
+const MARNM_LOCATOR = " _MARNM";
+/** The input a family tree was imported from (a GEDCOM file kept by the research), else why not. */
+export function importedTree(input) {
+    if (input.kind !== "tree" || !input.sha || !/\.ged$/i.test(input.name))
+        return `${input.id} is not a GEDCOM family tree`;
+    if (!input.source || !input.imported)
+        return `${input.id} was not imported (strom intake --no-import)`;
+    return undefined;
+}
+/** What the input's file gives as married names (_MARNM) that the people imported from it lack. */
+export function marriedNamesPlan(tree, input, text) {
+    const { records } = parseGedcomText(text);
+    const file = stromAppFile(records.find((r) => r.tag === "HEAD"));
+    const system = `gedcom:${input.sha.slice(0, 12)}`;
+    // the people the import made of the file (or added to): by the xref it kept; one merged since is the one it went into
+    const byXref = new Map();
+    for (const p of tree.list("person"))
+        for (const r of p.refs ?? [])
+            if (r.system === system)
+                byXref.set(r.id, p);
+    const live = (p) => {
+        for (let i = 0; p && i < 20; i++) {
+            if (!p.mergedInto)
+                return p.retracted ? undefined : p;
+            p = tree.get(p.mergedInto);
+        }
+        return undefined;
+    };
+    const plan = { input: input.id, source: input.source, add: [], have: [], unpaired: [] };
+    for (const r of records.filter((x) => x.tag === "INDI" && x.xref)) {
+        // NFC as every record (a file may write a name decomposed)
+        const married = importedMarnm(r, file).map((n) => ({ ...n, given: n.given.normalize("NFC"), surname: n.surname.normalize("NFC") }));
+        if (!married.length)
+            continue;
+        const p = live(byXref.get(r.xref));
+        if (!p) {
+            plan.unpaired.push({ xref: r.xref, name: (children(r, "NAME")[0]?.value ?? "?").replace(/\s+/g, " ").trim(), married });
+            continue;
+        }
+        for (const name of married) {
+            const had = p.names.some((n) => sameName(n, name)) || plan.add.some((a) => a.person === p.id && sameName(a.name, name));
+            (had ? plan.have : plan.add).push({ person: p.id, xref: r.xref, name });
+        }
+    }
+    return plan;
+}
+/** Add the names of a plan: each of the married kind, last, citing the import (the person's xref and _MARNM). */
+export function addMarriedNames(tree, plan) {
+    tree.withTreeLock(() => {
+        for (const a of plan.add) {
+            const name = { ...a.name, citations: [{ source: plan.source, locator: `${a.xref.replace(/@/g, "")}${MARNM_LOCATOR}` }] };
+            update(tree, a.person, "person", (p) => (p.names.some((n) => sameName(n, name)) ? p : { ...p, names: [...p.names, name] }), {
+                op: "person.name",
+                summary: `${a.person} name ${gedcomName(name)} (married) ← ${plan.source}`,
+                reason: `the married name ${plan.input} gives (_MARNM), left out when it was imported`,
+            });
+        }
+    });
+}
+/** Take back what addMarriedNames added from this input: the names citing its import there (another citation kept: only this one goes). */
+export function undoMarriedNames(tree, inputRec) {
+    const source = inputRec.source;
+    const ours = (c) => c.source === source && !!c.locator?.endsWith(MARNM_LOCATOR);
+    const gone = [];
+    if (!source)
+        return gone;
+    tree.withTreeLock(() => {
+        for (const p of tree.list("person")) {
+            const at = p.names.flatMap((n, i) => (i > 0 && n.kind === "married" && n.citations?.some(ours) ? [i] : []));
+            if (!at.length)
+                continue;
+            const hit = at.map((i) => p.names[i]);
+            update(tree, p.id, "person", (x) => ({
+                ...x,
+                names: x.names.flatMap((n, i) => {
+                    if (!at.includes(i))
+                        return [n];
+                    // cited by something else too: only this citation goes
+                    const rest = (n.citations ?? []).filter((c) => !ours(c));
+                    return rest.length ? [{ ...n, citations: rest }] : [];
+                }),
+            }), { op: "name.remove", summary: `${p.id} name ${hit.map(gedcomName).join(", ")} taken back`, reason: `the married names taken in from ${inputRec.id} taken back` });
+            for (const n of hit)
+                gone.push({ person: p.id, name: n });
+        }
+    });
+    return gone;
+}
 function oursByRefn(tree, treeId, people) {
     if (treeId && treeId !== tree.config.id)
         return people.map(() => undefined);

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.16.0-beta.2";
+export const VERSION = "1.16.0-beta.3";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.16.0-beta.2",
+  "version": "1.16.0-beta.3",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {