strom-research 1.6.0 → 1.6.1

package/assets/lang/cs.json

@@ -488,10 +488,13 @@
   "ui.sync.child.new": "{n}. {who}: dítě — {child}",
   "ui.sync.child.gone": "{n}. {who}: už to není jejich dítě — {child}",
   "ui.sync.person.gone": "{n}. už v něm není: {name}",
+  "ui.sync.place.coords": "{n}. {place}: poloha na mapě {from} → {at}",
+  "ui.sync.place.located": "{n}. {place}: poloha na mapě {at}",
   "ui.sync.do.add": "přidá se jako vodítko",
   "ui.sync.do.correct": "opraví vodítko výzkumu",
   "ui.sync.do.conflict": "rozpor k rozhodnutí (výzkum to má ze záznamu)",
   "ui.sync.do.user": "platí vaše úprava (údaj ze záznamu se stáhne s důvodem)",
+  "ui.sync.do.set": "výzkum převezme vaši polohu (žádný zápis ji nedokládá)",
   "ui.sync.do.pick": "jen když ho vyberete (--only)",
   "ui.sync.do.report": "nic se nemění — řekněte agentovi, co jste tím mysleli",
   "ui.sync.edits": "Vaše úpravy údajů doložených záznamem: {mode} (strom config set sync.edits conflict|user)",

package/assets/lang/de.json

@@ -488,10 +488,13 @@
   "ui.sync.child.new": "{n}. {who}: ein Kind — {child}",
   "ui.sync.child.gone": "{n}. {who}: nicht mehr ihr Kind — {child}",
   "ui.sync.person.gone": "{n}. nicht mehr darin: {name}",
+  "ui.sync.place.coords": "{n}. {place}: Lage auf der Karte {from} → {at}",
+  "ui.sync.place.located": "{n}. {place}: Lage auf der Karte {at}",
   "ui.sync.do.add": "als Hinweis übernommen",
   "ui.sync.do.correct": "berichtigt den Hinweis der Forschung",
   "ui.sync.do.conflict": "ein Widerspruch zum Entscheiden (die Forschung hat es aus einem Eintrag)",
   "ui.sync.do.user": "Ihre Änderung gilt (die Angabe aus dem Eintrag wird mit Grund zurückgezogen)",
+  "ui.sync.do.set": "die Forschung übernimmt Ihre Lage (kein Eintrag belegt sie)",
   "ui.sync.do.pick": "nur wenn Sie sie auswählen (--only)",
   "ui.sync.do.report": "nichts ändert sich — sagen Sie dem Agenten, was Sie meinten",
   "ui.sync.edits": "Ihre Änderungen an Angaben, die ein Eintrag belegt: {mode} (strom config set sync.edits conflict|user)",

package/dist/cli/ui.js

@@ -420,10 +420,13 @@ export const UI = {
     "ui.sync.child.new": "{n}. {who}: a child — {child}",
     "ui.sync.child.gone": "{n}. {who}: no longer their child — {child}",
     "ui.sync.person.gone": "{n}. no longer in it: {name}",
+    "ui.sync.place.coords": "{n}. {place}: on the map {from} → {at}",
+    "ui.sync.place.located": "{n}. {place}: on the map at {at}",
     "ui.sync.do.add": "added as a lead",
     "ui.sync.do.correct": "corrects the research's lead",
     "ui.sync.do.conflict": "a conflict for you to decide (the research has it from a record)",
     "ui.sync.do.user": "your edit wins (the record's fact withdrawn with the reason)",
+    "ui.sync.do.set": "the research takes your position (no record proves one)",
     "ui.sync.do.pick": "only when you pick it (--only)",
     "ui.sync.do.report": "nothing changes — tell the agent what you meant",
     "ui.sync.edits": "Your edits to facts a record proves: {mode} (strom config set sync.edits conflict|user)",

package/dist/commands/session.js

@@ -613,6 +613,8 @@ register({
                 // Close what the agent left open, record the metrics, export, commit.
                 const after = Tree.open(root, runEnv);
                 let s = after.get(session.id);
+                // strom worked for the agent when it closed the session itself or recorded something
+                const ranStrom = s.state !== "open" || sessionWrites(after, s.id) > 0;
                 if (s.state === "open")
                     s = closeSession(after, s, {
                         summary: result.outcome === "stopped" ? phrase(after.lang, "session.user") : phrase(after.lang, "session.agent", { outcome: result.outcome }),
@@ -656,7 +658,9 @@ register({
                     break;
                 }
                 // An agent that may not run strom can do nothing: stop, do not burn session after session.
-                if (result.denied?.some((d) => /^Bash: (\S*\/)?strom\b/.test(d))) {
+                // A refused command that only starts with strom (strom … && sed …, a loop) is no such thing
+                // when strom worked for it otherwise.
+                if (!ranStrom && result.denied?.some((d) => /^Bash: (\S*\/)?strom\b/.test(d))) {
                     stopCode = "denied";
                     break;
                 }

package/dist/commands/sync.js

@@ -21,6 +21,8 @@ function factText(f, lang) {
         return "—";
     return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang)].filter(Boolean).join(", ") || "—";
 }
+/** A position on the map as a map shows it: degrees, six decimals at most. */
+const point = (p) => `${+p.lat.toFixed(6)}, ${+p.lon.toFixed(6)}`;
 /** One change as the user reads it, with what strom does with it. */
 function changeLine(tree, c, incoming, lang) {
     const name = (key) => {
@@ -44,8 +46,12 @@ function changeLine(tree, c, incoming, lang) {
         text: truncate(c.text ?? "", 120),
         child: name(c.child),
         kids: c.kind === "family.new" && c.text ? ` + ${c.text.split(" ").filter(Boolean).map(name).join(", ")}` : "",
+        place: c.place?.name ?? "",
+        at: c.place ? point(c.place) : "",
+        from: c.place?.was ? point(c.place.was) : "",
     };
-    return `${ui(lang, `ui.sync.${c.kind}`, v)} → ${ui(lang, `ui.sync.do.${c.action}`)}`;
+    const key = c.kind === "place.coords" && !c.place?.was ? "ui.sync.place.located" : `ui.sync.${c.kind}`;
+    return `${ui(lang, key, v)} → ${ui(lang, `ui.sync.do.${c.action}`)}`;
 }
 function planText(tree, plan, incoming, file, lang, edits) {
     const shown = file.includes(" ") ? `"${file}"` : file;

package/dist/core/sync.js

@@ -40,6 +40,45 @@ const kindOf = (k) => (k === "CHR" ? "BAPM" : k);
 export const factKey = (f) => [kindOf(f.kind), f.date ?? "", exact(f.place), exact(f.value), f.date || f.place ? "" : fold(f.label)].join("|");
 /** A name for a comparison: "? /Novák/", "Jan //" and "Jan /?/" are the names the research has. */
 const nameKey = (n) => exact(n.replace(/[/?]/g, " "));
+/** A place's name as the Strom app keys its coordinates (placeKey of its places.ts): no accents, case, stops or commas. */
+export const placeKey = (s) => foldText(s.replace(/[.,;]/g, " ")).replace(/\s+/g, " ").trim();
+/** The Strom app's own key of a place's coordinates in its JSON (places.ts). */
+const appPlaceKey = (s) => s
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[.,;]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+/** GEDCOM's N50.042 / E15.358 (also a bare or negative number): degrees, the south and west negative. */
+function degrees(v, neg, max) {
+    const m = /^\s*([NSEW])?\s*(-?\d{1,3}(?:\.\d+)?)\s*$/i.exec(v ?? "");
+    if (!m)
+        return undefined;
+    const n = Number(m[2]) * (m[1]?.toUpperCase() === neg ? -1 : 1);
+    return Number.isFinite(n) && Math.abs(n) <= max ? n : undefined;
+}
+/** The places of a GEDCOM with their MAP > LATI/LONG, wherever a PLAC is. */
+function gedPlaces(records) {
+    const out = new Map();
+    const walk = (n) => {
+        for (const c of n.children) {
+            const map = c.tag === "PLAC" ? c.children.find((x) => x.tag === "MAP") : undefined;
+            const lat = map ? degrees(val(map, "LATI"), "S", 90) : undefined;
+            const lon = map ? degrees(val(map, "LONG"), "W", 180) : undefined;
+            const name = c.value.replace(/\s+/g, " ").trim();
+            if (lat !== undefined && lon !== undefined && name && !out.has(placeKey(name)))
+                out.set(placeKey(name), { name, lat, lon });
+            walk(c);
+        }
+    };
+    for (const r of records)
+        if (r.tag === "INDI" || r.tag === "FAM")
+            walk(r);
+    return out;
+}
+/** The same point: the Strom app keeps six decimals. */
+const samePoint = (a, b) => Math.abs(a.lat - b.lat) < 5e-7 && Math.abs(a.lon - b.lon) < 5e-7;
 /** The Strom app's "Birth (alternative record)": a second birth or death of ours coming back as an event of its own. */
 const ALTERNATIVE = {
     "birth (alternative record)": "BIRT", "death (alternative record)": "DEAT",
@@ -155,7 +194,7 @@ export function readGedcom(text) {
     }
     const treeId = val(head, "_STROM_TREE");
     const at = val(head, "_STROM_HEAD");
-    return { format: "gedcom", ...(treeId ? { treeId } : {}), ...(at ? { head: at } : {}), persons, families, problems };
+    return { format: "gedcom", ...(treeId ? { treeId } : {}), ...(at ? { head: at } : {}), persons, families, places: gedPlaces(records), problems };
 }
 /** The Strom app's life events → our kinds. */
 const APP_EVENTS = {
@@ -236,8 +275,19 @@ export function readStromJson(data) {
         }
         families.push({ partners, children: (u.childIds ?? []).map((c) => keys.get(c)).filter((k) => !!k), facts });
     }
+    // the app's coordinates are kept for the place's name (its placeKey): the names are its facts'
+    const places = new Map();
+    const geo = d.places && typeof d.places === "object" ? d.places : {};
+    for (const f of [...persons.values()].flatMap((p) => p.facts).concat(families.flatMap((x) => x.facts))) {
+        const k = f.place ? placeKey(f.place) : "";
+        const g = f.place ? geo[appPlaceKey(f.place)] : undefined;
+        if (!g || places.has(k) || typeof g.lat !== "number" || typeof g.lon !== "number")
+            continue;
+        if (Math.abs(g.lat) <= 90 && Math.abs(g.lon) <= 180)
+            places.set(k, { name: f.place, lat: g.lat, lon: g.lon });
+    }
     const r = d.research;
-    return { format: "strom-json", ...(r?.id ? { treeId: r.id } : {}), ...(r?.head ? { head: r.head } : {}), persons, families, problems: [] };
+    return { format: "strom-json", ...(r?.id ? { treeId: r.id } : {}), ...(r?.head ? { head: r.head } : {}), persons, families, places, problems: [] };
 }
 /** A file coming back: GEDCOM or the Strom app's JSON; empty or unreadable throws. */
 export function readTreeFile(file) {
@@ -635,8 +685,32 @@ export function planSync(tree, incoming, edits, opts = {}) {
                     push({ kind: "child.gone", action: "report", family: fam.id, partners, child: c });
         }
     }
+    // places on the map: no record proves a position, so the user's is taken — set where the research has none,
+    // or changed in the app since it was given (the research's as it was given); anything else only when picked
+    const ourPlaces = researchPlaces(tree);
+    for (const [k, p] of incoming.places ?? []) {
+        const mine = ourPlaces.get(k);
+        const here = mine?.coords;
+        if (here && samePoint(here, p))
+            continue;
+        const given = base?.places?.get(k);
+        if (given && samePoint(given, p))
+            continue; // as it was given: the research moved it since
+        const action = !here || (given && samePoint(given, here)) ? "set" : "pick";
+        push({ kind: "place.coords", action, place: { ...p, ...(mine ? { id: mine.id } : {}), ...(here ? { was: here } : {}) } });
+    }
     return { changes, base: !!base, ...(incoming.head ? { head: incoming.head } : {}), partial, identity };
 }
+/** The research's places by placeKey of each of their names — one with coordinates first, as the export gives them. */
+function researchPlaces(tree) {
+    const out = new Map();
+    for (const p of tree.list("place"))
+        if (!p.retracted)
+            for (const n of p.names)
+                if (!out.has(placeKey(n.name)) || (p.coords && !out.get(placeKey(n.name)).coords))
+                    out.set(placeKey(n.name), p);
+    return out;
+}
 /** Does the research's fact say all the file's fact says, and more: the same kind, and each of its date, place, value the same or missing in the file. */
 /**
  * The Strom app keeps a couple's marriages and divorces as the course of one union: two marriages with no divorce
@@ -798,6 +872,25 @@ export function applySync(tree, plan, incoming, source, only) {
                 applied.push({ do: "child.add", id: c.family, before: child });
                 break;
             }
+            case "place.coords": {
+                const p = c.place;
+                if (!p)
+                    break;
+                const coords = { lat: p.lat, lon: p.lon };
+                const mine = p.id ? tree.get(p.id) : undefined;
+                if (mine && !mine.retracted) {
+                    update(tree, mine.id, "place", ({ unlocated: _found, ...rest }) => ({ ...rest, coords }), {
+                        op: "place.edit",
+                        summary: `${mine.id} at ${p.lat}, ${p.lon}: ${reason}`,
+                    });
+                    applied.push({ do: "place.edit", id: mine.id, before: JSON.stringify({ coords: mine.coords, unlocated: mine.unlocated }) });
+                }
+                else {
+                    const made = create(tree, "place", { names: [{ name: p.name }], coords, jurisdictions: [], note: `the position from ${reason}` }, (id) => `+${id} place "${p.name}" (from ${source.id})`);
+                    applied.push({ do: "place.add", id: made.id });
+                }
+                break;
+            }
             default:
                 break;
         }
@@ -858,6 +951,17 @@ export function undoSync(tree, input) {
                 if (!tree.get(a.id)?.retracted)
                     retractPerson(tree, a.id, reason);
                 break;
+            case "place.edit": {
+                const b = JSON.parse(String(a.before ?? "{}"));
+                update(tree, a.id, "place", ({ coords: _now, unlocated: _u, ...p }) => ({ ...p, ...(b.coords ? { coords: b.coords } : {}), ...(b.unlocated ? { unlocated: b.unlocated } : {}) }), {
+                    op: "place.edit",
+                    summary: `${a.id} position back: ${reason}`,
+                });
+                break;
+            }
+            case "place.add":
+                update(tree, a.id, "place", (p) => ({ ...p, retracted: { at: now(), reason } }), { op: "place.retract", summary: `${a.id} retracted: ${reason}` });
+                break;
         }
         n++;
     }

package/dist/core/tree.js

@@ -23,7 +23,7 @@ import * as git from "./git.js";
 import { commitSeal, createKey, fingerprint, loadKey, sha256, signOp } from "./seal.js";
 import { stringifyCanonical } from "./json.js";
 export const TREE_FILE = "strom.json";
-export const VERSION = "1.6.0";
+export const VERSION = "1.6.1";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/gedcom/export.js

@@ -120,7 +120,7 @@ export function exportGedcom(tree, opts = {}) {
     // Places with coordinates, looked up by folded name.
     const coords = new Map();
     for (const pl of tree.list("place"))
-        if (pl.coords)
+        if (pl.coords && !pl.retracted)
             for (const n of pl.names)
                 coords.set(foldText(n.name), pl.coords);
     // What the research knows beyond the facts (the Strom profile, opts.research): read once.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {