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

package/CHANGELOG.cs.md

@@ -22,6 +22,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   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.
+- **Jeden archiv, jedna otázka.** Když obrazy jednoho archivu přicházejí z více adres (jeho web, album, server
+  obrazů), svolení archivu se žádá jednou a platí pro všechny, ne adresu po adrese.
 - **Linie výzkumu.** České texty všude říkají „linie výzkumu“, nikde už „směry“.
 
 ## 1.15.0

package/CHANGELOG.de.md

@@ -25,6 +25,8 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   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.
+- **Ein Archiv, eine Frage.** Kommen die Bilder eines Archivs von mehreren Adressen (seine Seite, ein Album, ein
+  Bildserver), wird die Erlaubnis des Archivs einmal erfragt und gilt für alle, nicht Adresse für Adresse.
 - **Forschungslinien auf Tschechisch.** Die tschechischen Texte sagen jetzt überall „linie výzkumu“ (Forschungslinien).
 
 ## 1.15.0

package/CHANGELOG.md

@@ -22,6 +22,8 @@ The changes of each version in short. The full notes and the install lines are o
   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.
+- **One archive, one question.** When one archive's images come from several hosts (its site, an album, an image
+  server), the permission it needs is asked once and decided for all of them, not host by host.
 - **Lines of research in Czech.** The Czech texts say „linie výzkumu“ (lines of research) everywhere now.
 
 ## 1.15.0

package/dist/cli/menu-archives.js

@@ -11,7 +11,7 @@ import { humanDay } from "./human.js";
 import { Tree } from "../core/tree.js";
 import { isArchive } from "../core/mode.js";
 import { bareHost, listConnectors, routeOf, routesOf } from "../core/connector.js";
-import { claimOf, loadArchives, rank } from "../core/terms.js";
+import { claimOf, loadArchives, pendingQuestions, questionHosts, rank } from "../core/terms.js";
 import { connectorFor, levelWords, tasksStanding, tasksWaitingOn, termsText, waysOffered, wokenLines } from "../core/archiveasks.js";
 import { wakeForArchive } from "../core/archivewait.js";
 import { archivesOverview, capWords, levelsOf, paceFor } from "../commands/archives.js";
@@ -53,8 +53,9 @@ export async function decideArchive(ctx, run, lang, root, host, q, all) {
     const title = a?.title ?? q?.title ?? c.manifest.title ?? host;
     const tree = root ? Tree.open(root, ctx.env) : undefined;
     const hosts = all && all.length > 1 ? all : [host];
-    // the command's target: the downloader for all its hosts at once, else the host
-    const target = hosts.length > 1 ? c.name : host;
+    // the command's target: the downloader for all its hosts at once, else the host — with every host of its question
+    // (strom allow archive decides a question of one archive for all its hosts)
+    const target = hosts.length > 1 && hosts.some((h) => !q?.archiveHosts?.includes(h)) ? c.name : host;
     out("");
     out(` ${t("ui.archive.item", { title, host: hosts.join(", ") })}`);
     out(`    ${termsText(lang, ctx.env, { host, ...(a?.quote ? { quote: a.quote } : q?.quote ? { quote: q.quote } : {}), ...(a?.terms ?? q?.terms ? { terms: (a?.terms ?? q?.terms) } : {}), ...(a?.quoteBy ? { quoteBy: a.quoteBy } : q?.quoteBy ? { quoteBy: q.quoteBy } : {}) })}`);
@@ -222,7 +223,7 @@ function hostStates(ctx, lang, c) {
 /** Settings → Archives → permissions: each archive of a downloader here, then the same choices as in What waits. */
 export async function archivePermissions(ctx, run, lang, root) {
     const t = translator(lang);
-    const pending = (hosts) => loadArchives(ctx.env).pending.find((p) => p.kind === "permission" && hosts.includes(p.host ?? ""));
+    const pending = (hosts) => pendingQuestions(ctx.env).find((p) => p.kind === "permission" && questionHosts(p).some((h) => hosts.includes(h)));
     await subMenu(ctx, lang, () => {
         const rows = archivesOverview(ctx);
         const connectors = connectorsHere(ctx);

package/dist/cli/menu-links.js

@@ -35,6 +35,7 @@ import { foldText, safeFolderName } from "../core/text.js";
 import { StromError } from "../core/errors.js";
 import { forgetTree } from "../commands/trees.js";
 import { archiveQuestions } from "../core/archiveasks.js";
+import { questionHosts } from "../core/terms.js";
 import { bareHost, listConnectors } from "../core/connector.js";
 import { decideArchive } from "./menu-archives.js";
 import { inboxOf, requestFile, sameGroup } from "../core/waiting.js";
@@ -173,11 +174,11 @@ export async function archiveAsked(ctx, run, lang, root, host) {
     const tree = Tree.open(root, ctx.env);
     if (isArchive(tree))
         return stop(ctx, t("ui.link.archive.none"));
-    const q = archiveQuestions(tree).find((p) => p.kind === "permission" && p.host === host);
+    const q = archiveQuestions(tree).find((p) => p.kind === "permission" && questionHosts(p).includes(host));
     const known = q ? true : listConnectors(ctx.settings.shared()?.value, ctx.env).some((c) => c.manifest.hosts.map(bareHost).includes(host));
     if (!known)
         return stop(ctx, t("ui.link.archive.none"));
-    return decideArchive(ctx, run, lang, root, host, q);
+    return decideArchive(ctx, run, lang, root, host, q, q?.archiveHosts);
 }
 /** A direction of the research paused, ended (each with the person's reason, if they give one) or taken up again. */
 export async function directionDo(ctx, run, lang, root, id, what) {

package/dist/cli/menu-waiting.js

@@ -426,7 +426,7 @@ async function decide(ctx, run, lang, root, w) {
         return void (await decideStory(ctx, run, lang, root, w.story, storyOf(tree, w.story)));
     const q = w.question;
     if (q?.kind === "permission" && q.host)
-        return void (await decideArchive(ctx, run, lang, root, q.host, q));
+        return void (await decideArchive(ctx, run, lang, root, q.host, q, q.archiveHosts));
     if (q?.kind === "takeover")
         return decideTakeover(ctx, run, lang, q);
     if (q?.kind === "milder" && q.connector) {

package/dist/commands/archives.js

@@ -19,7 +19,7 @@ import { currentSession } from "../core/session.js";
 import { noteSessionWait, wakeForArchive } from "../core/archivewait.js";
 import { connectorFor, levelWords, waysOffered, wokenLines } from "../core/archiveasks.js";
 import { claudeHere } from "../cli/menu-parts.js";
-import { acceptConnectors, allows, keepReadings, askLater, claimOf, connectorLevels, grantWay, hostOf, humanPace, keepNetVerdict, keyHost, latchedPace, LEVELS, loadArchives, pendingQuestions, rank, settlePending, revokeWay, setFloor, strictest, takenOverWaiting, windowShown, WAYS, } from "../core/terms.js";
+import { acceptConnectors, allows, keepReadings, askLater, claimOf, connectorLevels, grantWay, hostOf, humanPace, keepNetVerdict, keyHost, latchedPace, LEVELS, loadArchives, pendingQuestions, questionHosts, rank, settlePending, revokeWay, setFloor, strictest, takenOverWaiting, windowShown, WAYS, } from "../core/terms.js";
 /** The images (or pages) of an archive wait for the person's decision: nothing was asked of the archive. */
 export class NeedsPermissionError extends StromError {
     hosts;
@@ -466,7 +466,10 @@ export function syncTrees(ctx) {
     }
     return synced;
 }
-/** The hosts a name stands for: a connector's (its name), else the connector hosts on that host or site — never wider. */
+/**
+ * The hosts a name stands for: a connector's (its name), else the connector hosts on that host or site — never wider,
+ * but for the other hosts of one archive whose question waits with it (one archive, one decision).
+ */
 function targetHosts(ctx, target) {
     const all = listConnectors(shared(ctx), ctx.env);
     const byName = all.find((c) => c.name === target);
@@ -477,6 +480,14 @@ function targetHosts(ctx, target) {
     const hosts = [...new Set(connectors.flatMap((c) => c.manifest.hosts.map(bareHost).filter((h) => hostAllowed(h, [given]) || hostAllowed(given, [h]))))];
     if (!hosts.length)
         throw new UsageError(`no connector reaches ${given}`, { hint: all.length ? `connectors: ${all.map((c) => `${c.name} (${c.manifest.hosts.join(", ")})`).join(", ")}` : "none yet: strom connector list" });
+    const reached = new Set(connectors.flatMap((c) => c.manifest.hosts.map(bareHost)));
+    for (const q of pendingQuestions(ctx.env)) {
+        const its = questionHosts(q);
+        if (q.kind === "permission" && its.some((h) => hosts.includes(h)))
+            for (const h of its)
+                if (reached.has(h) && !hosts.includes(h))
+                    hosts.push(h);
+    }
     return { hosts, connectors };
 }
 const WAY_TEXT = { slow: "images slowly, at a person's pace", browser: "images through the browser on this computer", manual: "images by hand only" };

package/dist/commands/meta.js

@@ -113,7 +113,7 @@ function orientation(ctx) {
         // the ways as the menu and the bridge offer them (a site only a browser goes to, a bot check: never slowly)
         const connectors = listConnectors(ctx.settings.shared()?.value, ctx.env);
         const claude = claudeHere(ctx, tree.config);
-        base.permissions = asked.map((q) => ({ host: q.host, title: q.title ?? q.host, ...(q.connector ? { connector: q.connector } : {}), since: q.at, tries: q.tries ?? 1, tasks: tasksStanding(tree, q), command: `strom allow archive ${q.host} --way ${waysOffered(connectorFor(connectors, q.host, q.connector), claude, q.way, !!q.browserOnly).join("|")}` }));
+        base.permissions = asked.map((q) => ({ host: q.host, ...(q.archiveHosts ? { hosts: q.archiveHosts } : {}), title: q.title ?? q.host, ...(q.connector ? { connector: q.connector } : {}), since: q.at, tries: q.tries ?? 1, tasks: tasksStanding(tree, q), command: `strom allow archive ${q.host} --way ${waysOffered(connectorFor(connectors, q.host, q.connector), claude, q.way, !!q.browserOnly).join("|")}` }));
     }
     const stories = ctx.settings.stories(tree.config);
     base.stories = !stories.on ? "off" : stories.said || told.stories ? "on" : "tell";

package/dist/core/archiveasks.js

@@ -7,7 +7,7 @@ import { actsAsArchive } from "./state.js";
 import { waitsOnHost } from "./archivewait.js";
 import { waitsForDecision } from "./queue.js";
 export { savedInInbox } from "./archivewait.js";
-import { claimOf, pendingQuestions, termsFor } from "./terms.js";
+import { claimOf, pendingQuestions, questionHosts, termsFor } from "./terms.js";
 import { bareHost, listConnectors, routesOf } from "./connector.js";
 import { ui } from "../cli/ui.js";
 import { humanDay } from "../cli/human.js";
@@ -52,7 +52,7 @@ export function tasksWaitingOn(tree, host) {
  * those the queue holds back for it, and those a fetch needed it for (still to be done) — their IDs.
  */
 export function tasksStanding(tree, q) {
-    const ids = new Set(tasksWaitingOn(tree, q.host).map((t) => t.id));
+    const ids = new Set(questionHosts(q).flatMap((h) => tasksWaitingOn(tree, h).map((t) => t.id)));
     const held = waitsForDecision(tree, [q]);
     for (const t of tree.list("task"))
         if (t.state === "open" && held(t))
@@ -169,12 +169,13 @@ export function archiveWaitingItems(tree, shared, claude) {
                 {
                     kind: "permission",
                     id: q.key,
-                    what: ui(lang, "ui.archive.item", { title, host: q.host }),
+                    what: ui(lang, "ui.archive.item", { title, host: questionHosts(q).join(", ") }),
                     on: termsText(lang, tree.env, q),
                     at: q.at,
                     since: q.at,
                     tries: q.tries ?? 1,
                     host: q.host,
+                    ...(q.archiveHosts ? { hosts: q.archiveHosts } : {}),
                     title,
                     ...(q.terms ? { terms: q.terms } : {}),
                     ...(q.quote ? { quote: q.quote } : {}),

package/dist/core/terms.js

@@ -186,12 +186,75 @@ export function updateArchives(env, change) {
  * know (a list grown since covers more) — none left, no question.
  */
 export function pendingQuestions(env) {
-    return loadArchives(env).pending.flatMap((q) => {
+    return oneArchive(loadArchives(env).pending.flatMap((q) => {
         if (q.kind !== "takeover" || !q.hosts)
             return [q];
         const left = (q.connectors ?? []).filter((n) => !q.hosts?.[n] || !coveredByTerms(env, q.hosts[n]));
         return left.length ? [{ ...q, connectors: left }] : [];
-    });
+    }));
+}
+/** The hosts a question is for: those of its archive, else its own. */
+export function questionHosts(q) {
+    return q.archiveHosts?.length ? q.archiveHosts : q.host ? [q.host] : [];
+}
+/**
+ * The questions about the images of one archive — its hosts (the site's pages, its image servers) asked one by one,
+ * the same connector, site and terms — read as one: since the first time asked, the tasks of them all (each once), the
+ * ways every host may go. Each host keeps its own question in the file (an older strom reads them as before).
+ */
+function oneArchive(qs) {
+    const groups = new Map();
+    const out = [];
+    for (const q of qs) {
+        if (q.kind !== "permission" || !q.host) {
+            out.push(q);
+            continue;
+        }
+        const key = JSON.stringify([q.connector ?? "", webDomain(q.host), q.terms ?? ""]);
+        const g = groups.get(key);
+        if (g)
+            g.push(q);
+        else {
+            const fresh = [q];
+            groups.set(key, fresh);
+            out.push(fresh);
+        }
+    }
+    return out.map((x) => (Array.isArray(x) ? (x.length === 1 ? x[0] : merged(x)) : x));
+}
+function merged(qs) {
+    const all = [...qs].sort((a, b) => a.at.localeCompare(b.at));
+    const first = all[0];
+    const latest = (f) => all.map(f).filter((x) => !!x).sort().at(-1);
+    const tasks = [];
+    for (const q of all)
+        for (const t of q.tasks ?? (q.tree && q.task ? [{ tree: q.tree, task: q.task }] : []))
+            if (!tasks.some((x) => x.tree === t.tree && x.task === t.task))
+                tasks.push(t);
+    const lastAsked = [...all].sort((a, b) => (a.last ?? a.at).localeCompare(b.last ?? b.at)).at(-1);
+    const browserOnly = all.some((q) => q.browserOnly);
+    const choices = all.every((q) => q.choices) ? first.choices.filter((w) => all.every((q) => q.choices.includes(w)) && !(browserOnly && w === "slow")) : undefined;
+    const title = all.find((q) => q.title)?.title;
+    const level = all.some((q) => q.level) ? strictest(...all.map((q) => q.level)) : undefined;
+    const way = browserOnly ? "browser" : first.way;
+    const window = latest((q) => q.window);
+    const last = latest((q) => q.last);
+    return {
+        ...first,
+        archiveHosts: [...new Set(all.map((q) => q.host))],
+        ...(title ? { title } : {}),
+        ...(level ? { level } : {}),
+        ...(way ? { way } : {}),
+        ...(choices ? { choices: choices.includes("manual") ? choices : [...choices, "manual"] } : {}),
+        ...(browserOnly ? { browserOnly } : {}),
+        ...(window ? { window } : {}),
+        ...(lastAsked.tree ? { tree: lastAsked.tree } : {}),
+        ...(lastAsked.task ? { task: lastAsked.task } : {}),
+        ...(tasks.length ? { tasks } : {}),
+        // one command asks all the archive's hosts at once: the most any host was needed
+        tries: Math.max(...all.map((q) => q.tries ?? 1)),
+        ...(last && last > first.at ? { last } : {}),
+    };
 }
 export function dropPending(s, key) {
     s.pending = s.pending.filter((p) => p.key !== key);

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.3";
+export const VERSION = "1.16.0-beta.4";
 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.3",
+  "version": "1.16.0-beta.4",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {