strom-research 1.0.0

package/dist/cli/ui.js

@@ -0,0 +1,266 @@
+// What a person reads: the guided menu, the setup wizard, the window of a
+// consent, the first message to the agent. In the user's language (the
+// research language), English built in, other languages in the same catalogs
+// as the research phrases (assets/lang/<code>.json, keys ui.*).
+import { localized } from "../core/phrases.js";
+export const UI = {
+    "ui.yes": "y",
+    "ui.no": "n",
+    "ui.enter": "Press Enter to go back to the menu.",
+    "ui.choose": "Choose",
+    "ui.bad.choice": "Please type one of the numbers.",
+    "ui.dialog.title": "Strom research",
+    "ui.dialog.yes": "Allow",
+    "ui.dialog.no": "Don't allow",
+    "ui.dialog.refused": "You did not allow it — nothing was changed.",
+    "ui.consent.level.auto": "Let the agent work on its own? It will ask you only about risky steps.",
+    "ui.consent.level.full": "Let the agent do everything except what strom forbids, without asking you?\n\nOnly for a computer where nothing else of value is kept.",
+    "ui.consent.connector": "Allow the downloader \"{name}\" to fetch images for the research?",
+    "ui.consent.connector.revoke": "Stop the downloader \"{name}\"?",
+    "ui.consent.host": "Allow automatic downloading from {host}?",
+    "ui.consent.host.revoke": "Stop automatic downloading from {host}?",
+    "ui.consent.connector.hosts": "It will reach only {hosts} — slowly, through strom's limiter.",
+    "ui.consent.connector.changed": "Its code changed since you allowed it.",
+    "ui.consent.connector.direct": "Warning: its code reaches the network itself, past strom's limiter.",
+    "ui.consent.connector.terms": "The archive's terms of use: {terms}",
+    "ui.consent.host.unblock": "{host} refused us. Allow it again — only if the archive said it is fine?",
+    "ui.consent.connectors.off": "Let downloaders run without asking you first?",
+    "ui.menu.title": "Strom research {version}",
+    "ui.menu.tree": "Family tree: {name} · {persons} people",
+    "ui.menu.waiting": "Waiting for you: {count}",
+    "ui.menu.working": "The agent is working on its own right now.",
+    "ui.menu.chat": "Continue the research with the agent",
+    "ui.menu.start": "Start the research with the agent",
+    "ui.menu.otheragent": "Talk with another agent this time",
+    "ui.menu.run": "Let the agent work on its own",
+    "ui.menu.waitlist": "What waits for you",
+    "ui.menu.results": "Results",
+    "ui.menu.settings": "Settings",
+    "ui.menu.doctor": "Check the installation",
+    "ui.menu.trees": "Another family tree",
+    "ui.menu.newtree": "Create a family tree",
+    "ui.menu.quit": "Quit",
+    "ui.menu.bye": "See you next time. Start again with: strom",
+    "ui.run.how": "How many tasks should the agent work on? (it stops earlier when there is nothing to do)",
+    "ui.run.start": "The agent works on its own now. You can stop it with Ctrl-C — nothing is lost.",
+    "ui.waiting.none": "Nothing waits for you.",
+    "ui.waiting.open": "Open the folder for the images?",
+    "ui.results.files": "Results (updated after every session):",
+    "ui.results.none": "No results yet — they appear after the first session.",
+    "ui.results.app": "For the Strom app: {file} — in the app choose Import and pick this file.",
+    "ui.results.app.maybe": "Do you use the Strom app? Import {file} into it.",
+    "ui.results.open": "Open the folder with the results?",
+    "ui.trees.pick": "Which family tree?",
+    "ui.trees.new": "a new family tree",
+    "ui.tree.name": "What should your family tree be called? (e.g. the family surname)",
+    "ui.tree.default": "My family",
+    "ui.chat.open": "Opening the conversation with the agent ({agent}). When you are done, type {exit}.",
+    "ui.chat.first": "Hello, I want to start researching my ancestors. Run `strom`, explain to me in a few sentences how we will work together, and ask me whom we are looking for and what we already know.",
+    "ui.chat.continue": "Let's continue the research. Run `strom`, tell me briefly where the research stands and what waits for me, suggest what to do next, and tell me in a sentence what I can ask you about the tree.",
+    "ui.setup.welcome": "Welcome to Strom research. Let's set up a few things — press Enter to accept the suggested answer.",
+    "ui.setup.again": "Settings — press Enter to keep the current value.",
+    "ui.setup.lang": "Language (cs, en, de, pl, …)",
+    "ui.setup.home": "Where to keep the research",
+    "ui.setup.git.ok": "✓ Git (history of the research): {version}",
+    "ui.setup.git.missing": "Git is missing — strom keeps the history of the research in it, so nothing gets lost.",
+    "ui.setup.git.wait": "Finish the installation in the window that opened, then press Enter.",
+    "ui.setup.git.manual": "Install it with: {command} — then start strom again.",
+    "ui.setup.agent.ok": "✓ AI agent: {name}",
+    "ui.setup.agent.pick": "Which AI agent should do the research?",
+    "ui.setup.agent.none": "No AI agent found — strom needs one: the agent does the research with you.",
+    "ui.setup.agent.install": "Install Claude Code now (recommended; you need a Claude subscription)",
+    "ui.setup.agent.guide": "Show me which agents there are (opens a page in the browser)",
+    "ui.setup.agent.later": "Later",
+    "ui.setup.agent.login": "The first time the agent starts, you log in — a browser window opens.",
+    "ui.setup.agent.manual": "Install an AI agent (how: {url}), then start strom again.",
+    "ui.setup.model": "Which model should do the research?",
+    "ui.setup.model.opus": "Opus — best at reading old handwriting (recommended)",
+    "ui.setup.model.sonnet": "Sonnet — faster; printed documents and everyday work",
+    "ui.setup.model.own": "Leave it to the agent",
+    "ui.setup.level": "What may the agent do without asking you?",
+    "ui.setup.level.ask": "Ask me about everything outside the research",
+    "ui.setup.level.auto": "Work on its own — ask only about risky steps (recommended)",
+    "ui.setup.level.full": "Everything without asking — only on a computer with nothing else of value",
+    "ui.setup.level.warn": "The agent will be able to run any program and change any of your files; strom still guards the research itself.",
+    "ui.setup.level.sure": "Really allow everything?",
+    "ui.setup.shortcut": "Put a \"Strom research\" shortcut on the desktop?",
+    "ui.setup.shortcut.done": "✓ Shortcut: {file}",
+    "ui.setup.skill": "✓ {agent} now knows strom in any folder.",
+    "ui.setup.app": "✓ The Strom app is on this computer — results will be ready to import into it.",
+    "ui.setup.done": "All set.",
+    "ui.app.opened": "Opening the Strom app ({where}).",
+    "ui.app.browser": "in your browser",
+    "ui.app.url": "Open it here: {url}",
+    "ui.app.installed": "The Strom app is installed ({kind}).",
+    "ui.app.install": "The Strom app opened in your browser. To install it as an app, click the install icon at the right end of the address bar (Chrome, Edge); in Safari choose File → Add to Dock.",
+    "ui.menu.app": "Open the Strom app",
+    "ui.chat.agent.missing": "{agent} is not installed — run the settings (strom setup) to install it.",
+    "ui.shortcut.done": "Shortcut on the desktop: {file}",
+    "ui.o.title": "strom {version} — genealogical research toolkit for AI agents",
+    "ui.o.rule": "The evidence lives here; change it ONLY through strom commands. New here: strom guide",
+    "ui.o.home": "home",
+    "ui.o.notsetup": "(not set up)",
+    "ui.o.tree": "tree",
+    "ui.o.lang": "lang",
+    "ui.o.langnote": "talk to the user and write research texts in this language",
+    "ui.o.data": "data",
+    "ui.o.counts": "{persons} persons · {families} families · check: {check}",
+    "ui.o.ok": "ok",
+    "ui.o.errors": "{n} errors",
+    "ui.o.warnings": "{n} warnings",
+    "ui.o.research": "research",
+    "ui.o.research.none": "research (none yet)",
+    "ui.o.trees": "trees",
+    "ui.o.working": "working now (other agents — never take their tasks)",
+    "ui.o.since": "since {time}",
+    "ui.o.on": "on {task}",
+    "ui.o.next": "next",
+    "ui.why.setup.human": "strom is not set up yet — it asks where to keep the research",
+    "ui.why.setup.agent": "strom is not set up yet: this creates {home} (tell the user; --home <dir> for another place)",
+    "ui.why.init": "there is no family tree yet",
+    "ui.why.pick": "several trees exist — pick one (it is remembered)",
+    "ui.why.check": "the evidence has problems (or was changed outside strom)",
+    "ui.why.runleft": "session {id} was left open by a run that stopped — the next run closes it and goes on",
+    "ui.why.running": "strom run is working (session {id}) — let it finish, or Ctrl-C in its window",
+    "ui.why.open.human": "session {id} is open — an agent is working, or it stopped without closing",
+    "ui.why.open.agent": "session {id} is open{on} — continue, then close it",
+    "ui.why.research": "the tree has no research yet",
+    "ui.why.waiting": "the research waits for you — see \"waiting for you\" above",
+    "ui.why.intake": "record first what the user knows (then tasks follow from it)",
+    "ui.why.run": "{n} task(s) in the queue — an AI agent works them",
+    "ui.why.session": "{n} task(s) in the queue",
+    "ui.why.frontier": "no open tasks — see what the research still lacks",
+    "ui.wait.title": "waiting for you ({n})",
+    "ui.wait.images": "images {images} of {book}",
+    "ui.wait.save": "save them into {dir}",
+    "ui.wait.how1": "scans go into the inbox, a folder per book, each named by its image number as the viewer counts it",
+    "ui.wait.how2": "(9.jpg; a zoomed-in part of it: 9a.jpg) — the next run registers them and the task comes back by itself",
+    "ui.run.summary": "{n} session(s) · stopped: {reason}",
+    "ui.run.stop.done": "done",
+    "ui.run.stop.user": "stopped by you",
+    "ui.run.stop.time": "time limit",
+    "ui.run.stop.empty": "no open tasks",
+    "ui.run.stop.problems": "the evidence has problems — strom check",
+    "ui.run.stop.denied": "the agent was not allowed to run strom — its permissions are wrong (.claude/settings.json of the tree); nothing more was started",
+    "ui.run.stop.limit": "subscription limit{resets}",
+    "ui.run.stop.resets": " (resets {at})",
+    "ui.run.stop.auth": "the agent is not logged in — run {command} once and log in",
+    "ui.run.stop.failed": "the agent failed: {detail}",
+    "ui.run.stopping": "■ stopping — the session is closed and its task goes back to the queue; Ctrl-C again to quit at once",
+    "ui.run.gone": "· {session} closed — its run had stopped{back}",
+    "ui.run.back": "; {task} is back in the queue",
+    "ui.run.start.session": "▶ {session} · {task} {what}",
+    "ui.run.parked": "  · {task} parked: {n} sessions in a row recorded nothing",
+    "ui.run.denied": "  · permissions refused {n}×: {what}",
+    "ui.tree.created": "✓ The family tree \"{name}\" is ready: {dir}",
+    "ui.chat.trust": "The first time, Claude Code asks whether you trust this folder. It is your family tree's folder, made by strom — confirm with \"Yes, proceed\".",
+    "ui.doc.program": "program",
+    "ui.doc.git": "git (history)",
+    "ui.doc.home": "research folder",
+    "ui.doc.shared": "scans and catalog",
+    "ui.doc.trees": "family trees",
+    "ui.doc.agent": "AI agents",
+    "ui.doc.knows": "agents know strom",
+    "ui.doc.level": "the agent may",
+    "ui.doc.model": "model",
+    "ui.doc.shortcut": "desktop shortcut",
+    "ui.doc.app": "Strom app",
+    "ui.doc.tree": "this family tree",
+    "ui.doc.innode": "strom {version} in Node {node}",
+    "ui.doc.oldnode": "Node {node} is too old (22.18 or newer)",
+    "ui.doc.missing": "missing",
+    "ui.doc.notsetup": "not set up yet",
+    "ui.doc.none": "none",
+    "ui.doc.yes": "yes",
+    "ui.doc.default": "default",
+    "ui.doc.noagent": "no AI agent installed",
+    "ui.doc.knows.yes": "yes, in any folder",
+    "ui.doc.knows.no": "not yet: {agents}",
+    "ui.doc.app.yes": "you use it",
+    "ui.doc.app.seen": "found on this computer",
+    "ui.doc.app.no": "not wanted",
+    "ui.doc.app.unknown": "not found",
+    "ui.doc.tree.ok": "{name}: data consistent and sealed",
+    "ui.doc.tree.bad": "{name}: {n} problem(s)",
+    "ui.doc.allok": "Everything needed is in place.",
+    "ui.doc.problems": "{n} problem(s) — do what the arrows say (strom setup offers to install what is missing).",
+    "ui.menu.fix": "Fix it now?",
+    "ui.chat.app.open": "The conversation opens in the {app} app. Confirm the family tree's folder there, then send the prepared message (Enter).",
+    "ui.chat.app.closed": "The {app} app did not open. Start it yourself, open the folder {dir} and write: {message}",
+    "ui.chat.app.auto": "So that the agent works on its own: in the menu under the message box choose \"Auto\" — once, Claude remembers it for this folder.",
+    "ui.chat.app.full": "So that the agent may do everything: in the menu under the message box choose \"Bypass permissions\" (turn it on in Claude's settings first).",
+    "ui.setup.where": "Where do you want to talk with the agent?",
+    "ui.setup.where.app": "In the {app} app — the easiest (recommended)",
+    "ui.setup.where.terminal": "In the terminal ({agent}) — for experienced users",
+    "ui.doc.where": "where you talk",
+    "ui.doc.where.app": "the {app} app",
+    "ui.doc.where.terminal": "the terminal ({agent})",
+    "ui.run.needscli": "Working on its own needs {agent} in the terminal (the app alone cannot) — strom setup offers to install it.",
+    "ui.fix.git.download": "Download git for strom (about {mb} MB — the official Git for Windows, used by strom only, no installation)?",
+    "ui.fix.git.window": "Git comes with Apple's command line tools. A window of the system installs them (a few minutes). Open it?",
+    "ui.fix.git.downloading": "Downloading git…",
+    "ui.fix.git.inwindow": "Finish the installation in the window of the system, then run strom doctor again.",
+    "ui.fix.failed": "It did not work: {detail}",
+    "ui.fix.app": "Open the Strom app in the browser, to install it?",
+    "ui.fix.nothing": "Nothing strom can fix by itself — see the arrows.",
+    "ui.why.git.human": "git is missing — strom keeps the history of the research in it",
+    "ui.why.git.agent": "git is missing (strom keeps the research history in it): tell the user, then run this — the user says yes in a window of the system",
+    "ui.o.results": "results",
+    "ui.o.results.installed": "{file} — for the Strom app, installed here: strom app opens it (in the app: Import; on the web: {url})",
+    "ui.o.results.offer": "{file} — for the Strom app, not installed here yet: offer the user to install it from {url} (strom app install opens it there)",
+    "ui.o.results.plain": "{file} — for any family tree program",
+    "ui.o.results.installed.live": "{file} — for the Strom app, installed here: strom app opens this research in it, and while you work the app follows it live (what you record shows there by itself) — offer it once",
+    "ui.o.results.offer.live": "{file} — for the Strom app, not installed here yet: offer the user to watch the research grow in it live — installed from {url} (strom app install opens it there and says where to click), then strom app",
+    "ui.chat.handover": "The research goes on in its own conversation: a new window opened with {agent} in your family tree's folder. Continue there — this conversation can end.",
+    "ui.chat.handover.failed": "A new window could not be opened here. Start the research yourself: run strom in a terminal (or the Strom research shortcut on the desktop).",
+    "ui.chat.handover.end": "Continue there — this conversation can end.",
+    "ui.why.handover": "the research belongs in its own conversation in the tree folder (its permissions, no asking at every step): this opens it — tell the user to continue there; go on here only if they want",
+    "ui.app.research": "Opening the research {name} in the Strom app ({where}): the first time as a new tree, after that the same tree, updated.",
+    "ui.app.following": "The Strom app follows the research {name} while it goes on ({where}): what is found shows there by itself.",
+    "ui.o.stories": "stories",
+    "ui.o.stories.tell": "on (the default): when the research starts, tell the user in a sentence that you will also write stories of their ancestors for the family book in the Strom app, and that they may say no — strom config set stories no (yes: strom config set stories yes)",
+    "ui.o.stories.on": "on: strom proposes a story once records tell a life (narrate tasks)",
+    "ui.o.stories.off": "off (the user said no) — do not bring it up",
+    "ui.setup.model.strong": "The research needs a strong model — it reads old handwriting and weighs the records: in {agent}, choose its best model, not a fast or mini one.",
+    "ui.chat.app.model": "In {app}, choose its best model for the research (not a fast or mini one): it reads old handwriting.",
+    "ui.setup.stories": "Should the agent also write stories of your ancestors — a few paragraphs about each life, from the records it finds, for the family book in the Strom app?",
+    "ui.setup.stories.yes": "Yes (recommended)",
+    "ui.setup.stories.no": "No — just the family tree and its sources",
+    "ui.uninstall.agent": "what {agent} knows of strom",
+    "ui.uninstall.shortcut": "the shortcut",
+    "ui.uninstall.git": "strom's own git",
+    "ui.uninstall.path": "the installer's PATH entry",
+    "ui.uninstall.program": "the program",
+    "ui.uninstall.list": "strom takes this off your computer:",
+    "ui.uninstall.keeps": "Your research stays ({home}), and so do your settings with the keys that seal it ({config}) — delete them yourself only if you never want them again.",
+    "ui.uninstall.sure": "Uninstall strom?",
+    "ui.uninstall.kept": "Nothing was removed.",
+    "ui.uninstall.window": "Uninstall strom from this computer? Your research stays.",
+    "ui.uninstall.nothing": "Nothing of strom's to take off this computer.",
+    "ui.uninstall.npm": "The program itself (installed with npm): npm uninstall -g strom-research",
+    "ui.uninstall.done": "strom is uninstalled. Thank you for researching with it.",
+    "ui.menu.update.line": "A new version of strom is out: {version}.",
+    "ui.menu.update": "Update strom to {version}",
+    "ui.doc.update": "new version",
+    "ui.doc.update.new": "{version} is out",
+    "ui.update.unknown": "The newest version of strom could not be learned.",
+    "ui.update.current": "strom {version} is the newest version.",
+    "ui.update.available": "A new version is out: {version} (this is {current}) — strom update installs it.",
+    "ui.update.npm": "A new version is out: {version}. strom is installed with npm here: npm install -g strom-research@latest",
+    "ui.update.sure": "Update strom from {current} to {version}? Your research stays as it is.",
+    "ui.update.later": "Not now — strom update any time.",
+    "ui.update.downloading": "Downloading strom {version}…",
+    "ui.update.failed": "The update did not work: {detail}. strom stays as it was.",
+    "ui.update.done": "✓ strom is updated: {previous} → {version}.",
+    "ui.o.update": "update",
+    "ui.o.update.new": "{version} is out (this is {current}) — tell the user; strom update installs it with their yes",
+    "ui.app.drag": "The Strom app opened. Drag the file {file}{shown} into its window — the first time it becomes a new tree, after that the same tree is updated. With Chrome or Edge on this computer, strom hands it over by itself.",
+    "ui.app.drag.shown": " (shown in the file window)",
+    "ui.app.nolive": "Following the research live needs Chrome or Edge — Safari does not let a web page reach this computer.",
+    "ui.doc.installed": "strom {version} on its own Node {node} (official, from nodejs.org)",
+    "ui.update.source": "A new version is out: {version}. This strom runs from its sources: git pull",
+};
+/** A text for the person, in their language. */
+export function ui(lang, key, values = {}) {
+    return localized(lang, key, UI[key], values);
+}

package/dist/cli/wizard.js

@@ -0,0 +1,142 @@
+// The setup wizard: what a person answers once, and can change any time by
+// running it again (every answer is pre-filled with the current value). In
+// their language; Enter takes the suggestion. It checks and offers to install
+// git and an AI agent, and settles the model and what the agent may do alone.
+// Quietly it teaches the installed agents about strom and notices the Strom app.
+import fs from "node:fs";
+import path from "node:path";
+import { ui } from "./ui.js";
+import { isValidLang, langName } from "../core/lang.js";
+import { gitVersion } from "../core/git.js";
+import { fixGit, offerAgent } from "./fixes.js";
+import { agentsHere, DESKTOP_APPS } from "../core/apps.js";
+import { PROFILES } from "../agents/profiles.js";
+import { writeStored, PERMISSION_LEVELS } from "../core/config.js";
+import { globalTargets, installGlobal } from "../agents/global.js";
+import { noticeStromApp, researchUrl } from "../core/stromapp.js";
+import { createShortcut } from "../core/shortcut.js";
+import { desktopDir } from "../core/paths.js";
+import { ensureShared } from "../commands/setup.js";
+/** The shortcut's name, in the user's language. */
+export function shortcutName(lang) {
+    return ui(lang, "ui.dialog.title");
+}
+function shortcutExists(ctx, lang) {
+    const dir = desktopDir(ctx.env);
+    const name = shortcutName(lang);
+    return [`${name}.command`, `${name}.cmd`, "strom-research.desktop"].some((f) => fs.existsSync(path.join(dir, f)));
+}
+export async function setupWizard(ctx) {
+    const s = ctx.settings;
+    const cfg = s.config;
+    const out = (line = "") => ctx.io.stdout(line + "\n");
+    const first = !cfg.home;
+    let lang = cfg.lang ?? s.lang().value;
+    out(ui(lang, first ? "ui.setup.welcome" : "ui.setup.again"));
+    out();
+    // 1. Language — everything after is in it.
+    for (;;) {
+        const a = (await ctx.ask(ui(lang, "ui.setup.lang"), lang)).toLowerCase();
+        if (isValidLang(a)) {
+            lang = a;
+            break;
+        }
+    }
+    // 2. Where the research lives.
+    const home = ctx.resolvePath(await ctx.ask(ui(lang, "ui.setup.home"), ctx.display(s.home()?.value ?? s.suggestedHome())));
+    cfg.lang = lang;
+    cfg.home = home;
+    s.save();
+    fs.mkdirSync(home, { recursive: true });
+    fs.mkdirSync(s.trees().value, { recursive: true });
+    ensureShared(s.shared().value);
+    // 3. Git (strom doctor --fix does the same).
+    const git = gitVersion(ctx.env);
+    if (git)
+        out(ui(lang, "ui.setup.git.ok", { version: git }));
+    else {
+        out(ui(lang, "ui.setup.git.missing"));
+        await fixGit(ctx, out);
+    }
+    // 4. The AI agent — its CLI or its desktop app — and where the person talks with it.
+    let here = agentsHere(ctx.env);
+    let installed = here.map((a) => a.id);
+    if (installed.length === 0) {
+        await offerAgent(ctx, out);
+        here = agentsHere(ctx.env);
+        installed = here.map((a) => a.id);
+    }
+    let agent;
+    if (installed.length === 1)
+        agent = installed[0];
+    else if (installed.length > 1) {
+        const current = Math.max(0, installed.indexOf(cfg.agent ?? "claude"));
+        const i = await ctx.choose(ui(lang, "ui.setup.agent.pick"), installed.map((id) => ({ label: PROFILES[id].name })), current);
+        agent = installed[i ?? current];
+    }
+    if (agent) {
+        cfg.agent = agent;
+        out(ui(lang, "ui.setup.agent.ok", { name: PROFILES[agent].name }));
+        // Both the app and the CLI: the person chooses (the app is the easiest); one of them: that one.
+        const has = here.find((a) => a.id === agent);
+        if (has.app && has.cli) {
+            const app = DESKTOP_APPS[agent].name;
+            const current = cfg.agentWhere === "terminal" ? 1 : 0;
+            const i = await ctx.choose(ui(lang, "ui.setup.where"), [{ label: ui(lang, "ui.setup.where.app", { app }) }, { label: ui(lang, "ui.setup.where.terminal", { agent: PROFILES[agent].name }) }], current);
+            cfg.agentWhere = (i ?? current) === 1 ? "terminal" : "app";
+        }
+    }
+    else
+        out(ui(lang, "ui.setup.agent.manual", { url: researchUrl(lang, "agents") }));
+    // 5. The model (Claude Code: the one choice that matters for reading old hands).
+    if (agent === "claude") {
+        const models = ["opus", "sonnet", undefined];
+        const current = cfg.models?.claude?.lead;
+        const suggested = current === undefined ? (first ? 0 : 2) : Math.max(0, models.indexOf(current));
+        const i = await ctx.choose(ui(lang, "ui.setup.model"), [{ label: ui(lang, "ui.setup.model.opus") }, { label: ui(lang, "ui.setup.model.sonnet") }, { label: ui(lang, "ui.setup.model.own") }], suggested);
+        writeStored(cfg, "model.lead", "claude", models[i ?? suggested]);
+    }
+    else if (agent)
+        out(ui(lang, "ui.setup.model.strong", { agent: PROFILES[agent].name }));
+    // 5b. Stories of the ancestors for the family book: on unless the person says no.
+    const si = await ctx.choose(ui(lang, "ui.setup.stories"), [{ label: ui(lang, "ui.setup.stories.yes") }, { label: ui(lang, "ui.setup.stories.no") }], cfg.stories === "no" ? 1 : 0);
+    cfg.stories = (si ?? (cfg.stories === "no" ? 1 : 0)) === 1 ? "no" : "yes";
+    // 6. What the agent may do without asking.
+    const now = s.agentPermissions();
+    const labels = { ask: ui(lang, "ui.setup.level.ask"), auto: ui(lang, "ui.setup.level.auto"), full: ui(lang, "ui.setup.level.full") };
+    const li = await ctx.choose(ui(lang, "ui.setup.level"), PERMISSION_LEVELS.map((l) => ({ label: labels[l] })), PERMISSION_LEVELS.indexOf(now));
+    let level = PERMISSION_LEVELS[li ?? PERMISSION_LEVELS.indexOf(now)];
+    if (level === "full" && now !== "full") {
+        out(ui(lang, "ui.setup.level.warn"));
+        if (!(await ctx.confirm(ui(lang, "ui.setup.level.sure"), false)))
+            level = now;
+    }
+    cfg.agentPermissions = level;
+    s.save();
+    // 7. A shortcut on the desktop (asked once; refreshed quietly after).
+    if (!shortcutExists(ctx, lang)) {
+        if (await ctx.confirm(ui(lang, "ui.setup.shortcut"), true)) {
+            try {
+                for (const f of createShortcut(shortcutName(lang), ctx.env))
+                    out(ui(lang, "ui.setup.shortcut.done", { file: ctx.display(f) }));
+            }
+            catch {
+                // no desktop folder we may write to: the menu is still one command away
+            }
+        }
+    }
+    else
+        createShortcut(shortcutName(lang), ctx.env);
+    // Quietly: the installed agents learn about strom; the Strom app is noticed.
+    const taught = new Set();
+    for (const t of globalTargets(ctx.env).filter((t) => installed.includes(t.agent)))
+        if (installGlobal(t))
+            taught.add(t.agent);
+    for (const a of taught)
+        out(ui(lang, "ui.setup.skill", { agent: PROFILES[a].name }));
+    if (noticeStromApp(s, ctx.env, { look: true }))
+        out(ui(lang, "ui.setup.app"));
+    out();
+    out(`${ui(lang, "ui.setup.done")}  (${langName(lang, lang)} · ${ctx.display(home)})`);
+    return { home, lang, ...(agent ? { agent } : {}), permissions: level };
+}

package/dist/cli.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// strom — genealogical research toolkit for AI agents.
+import fs from "node:fs";
+import { main } from "./cli/main.js";
+// Windows consoles: make sure non-ASCII names print correctly.
+if (process.platform === "win32")
+    process.stdout.setDefaultEncoding?.("utf8");
+const code = await main(process.argv.slice(2), {
+    stdout: (s) => process.stdout.write(s),
+    stderr: (s) => process.stderr.write(s),
+    tty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    ...(process.stdin.isTTY ? {} : { stdinText: () => fs.readFileSync(0, "utf8") }),
+}, process.env, process.cwd());
+process.exitCode = code;