driggsby 0.8.0 → 0.9.0

package/dist/import/import-command.js

@@ -0,0 +1,307 @@
+// driggsby import: send a bank or card statement CSV to Driggsby into the
+// account the person names, follow it to the end,
+// answer its rare question, and undo it; and driggsby accounts list. Built for agents with
+// no Driggsby context: the file (or the ID Driggsby gives it) is the only
+// handle, repeating any command is safe, `--wait` never outlasts a coding
+// agent's command limit, and every output ends with the exact next command
+// (import-render.ts holds that contract).
+import { apiBaseUrl } from "../api/base-url.js";
+import { CliError } from "../cli-error.js";
+import { defaultCredentialEnvironment } from "../credentials/store.js";
+import { deployFailure, requireDeploySession, SIGN_IN_AGAIN_MESSAGE } from "../deploy/api-session.js";
+import { wrapProse } from "../terminal-text.js";
+import { GENERIC_TOOL_TROUBLE } from "../dev/dev-servers.js";
+import { accounts, answer, DriggsbyBusy, findByFile, findByRef, IMPORTS_NOT_AVAILABLE_MESSAGE, list, TROUBLE, undo, upload, } from "./import-client.js";
+import { accountFlags, CLI, kindWord, renderAccounts, renderList, renderNotUndoable, renderQuestion, renderStarted, renderStatus, renderUndoPreview, undoneLine, } from "./import-render.js";
+import { resolveTarget, shellWord, tooLargeToImport } from "./import-target.js";
+import {} from "./import-view.js";
+// Under Claude Code's 2-minute limit for one command, counted from the
+// command's start (an upload's time included), so a wait is never cut off
+// mid-poll; the output says to run the same command again. Every 3 seconds
+// keeps an agent waiting on a few imports at once well inside Driggsby's
+// per-minute limit on tool calls.
+export const WAIT_MS = 90_000;
+const POLL_MS = 3_000;
+// What running the same command again wouldn't fix; anything else mid-wait
+// ends the wait where it stands.
+const SIGNED_OUT = new Set([SIGN_IN_AGAIN_MESSAGE, IMPORTS_NOT_AVAILABLE_MESSAGE]);
+// Refusals about naming the account, whose fix starts from the account list.
+const ACCOUNT_REFUSALS = new Set(["account_required", "account_invalid", "account_not_found"]);
+const NOTHING_TO_UNDO = { text: "Nothing to undo: no import of this file is in Driggsby right now.\n", exitCode: 0 };
+function defaultImportIo() {
+    const interactive = process.stdin.isTTY && process.stdout.isTTY;
+    return {
+        out: (text) => {
+            process.stdout.write(text);
+        },
+        now: () => new Date(),
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        ask: interactive
+            ? async (question) => {
+                const { createInterface } = await import("node:readline/promises");
+                const readline = createInterface({ input: process.stdin, output: process.stdout });
+                try {
+                    return await readline.question(question);
+                }
+                finally {
+                    readline.close();
+                }
+            }
+            : null,
+    };
+}
+export async function runImport(options, environment = defaultCredentialEnvironment(), io = defaultImportIo()) {
+    const baseUrl = apiBaseUrl(environment.env);
+    try {
+        const session = await requireDeploySession(environment);
+        const rendered = options.action === "list"
+            ? renderList(await list(session), context(io))
+            : options.action === "accounts"
+                ? renderAccounts(await accounts(session))
+                : options.action === "undo"
+                    ? await runUndo(session, options, io)
+                    : await runStart(session, options, io);
+        io.out(rendered.text);
+        return rendered.exitCode;
+    }
+    catch (error) {
+        if (error instanceof DriggsbyBusy) {
+            throw new CliError(`Driggsby is busy right now. Run the same command again in a minute:\n  ${retryCommand(options)}`, 1);
+        }
+        // An answer the CLI couldn't read ends, like every output, on the command
+        // to run.
+        if (error instanceof CliError && (error.message === TROUBLE || error.message === GENERIC_TOOL_TROUBLE)) {
+            throw new CliError(`${error.message} Then run the same command again:\n  ${retryCommand(options)}`, 1);
+        }
+        throw deployFailure(error, baseUrl, retryCommand(options));
+    }
+}
+async function runStart(session, options, io) {
+    const startedAt = io.now().getTime();
+    const target = await resolveTarget(options.target);
+    const given = answerGiven(options);
+    const typedFile = target.kind === "file" ? shellWord(target.typed) : null;
+    let outcome;
+    let created = false;
+    let uploaded = false;
+    if (target.kind === "ref") {
+        if (options.account !== null || options.create !== null) {
+            throw new CliError(`${wrapProse("--account and --create-account name the account a file goes in; an import's ID already has one. To see where it stands:")}\n` +
+                `  ${CLI} import ${target.ref}`, 2);
+        }
+        outcome = await findByRef(session, target.ref);
+    }
+    else {
+        outcome = await findByFile(session, target.sha256, named(options));
+        if (outcome.kind === "refused" && outcome.code === "not_found") {
+            const file = typedFile ?? "<FILE>";
+            if (given !== null) {
+                throw new CliError(`${wrapProse("--dates and --amounts answer a question an import asked, and this file hasn't been imported yet. Start it first:")}\n` +
+                    `  ${CLI} import ${file} --account <ID>`, 2);
+            }
+            outcome = await upload(session, target.file, destination(options, file));
+            uploaded = true;
+            created = outcome.kind === "import" && outcome.created;
+        }
+    }
+    if (outcome.kind === "import" && !created && given !== null) {
+        outcome = await answer(session, outcome.view.ref, given);
+    }
+    if (outcome.kind === "refused") {
+        return renderRefusal(outcome, { typedFile, retry: retryCommand(options), uploaded, create: options.create });
+    }
+    const startedIn = outcome.view.state;
+    const view = options.wait ? await waitFor(session, outcome.view, io, startedAt) : outcome.view;
+    if (created && !options.wait) {
+        return renderStarted(view);
+    }
+    return renderStatus(view, {
+        compact: options.wait && startedIn === "categorizing",
+        repeated: target.kind === "file" && !created && given === null,
+        unchanged: outcome.note !== null,
+        rerun: { file: typedFile, account: options.account, create: options.create },
+    }, context(io));
+}
+async function runUndo(session, options, io) {
+    let startedAt = io.now().getTime();
+    // A file over the import limit was never imported.
+    if (await tooLargeToImport(options.target)) {
+        return NOTHING_TO_UNDO;
+    }
+    const target = await resolveTarget(options.target);
+    const found = target.kind === "ref" ? await findByRef(session, target.ref) : await findByFile(session, target.sha256, null);
+    if (found.kind === "refused") {
+        if (found.code === "not_found" && target.kind === "file") {
+            // Never imported, or already undone: either way nothing of it is left.
+            return NOTHING_TO_UNDO;
+        }
+        return renderRefusal(found, { typedFile: null, retry: retryCommand(options), uploaded: false });
+    }
+    const previewed = await undo(session, found.view.ref, false);
+    if (previewed.kind === "refused") {
+        return renderRefusal(previewed, { typedFile: null, retry: retryCommand(options), uploaded: false });
+    }
+    const preview = previewed.undo;
+    if (preview === null) {
+        throw new CliError("Driggsby couldn't say what undo would remove just now. Please try again in a minute.", 1);
+    }
+    if (!preview.undoable) {
+        return renderNotUndoable(previewed.view, preview);
+    }
+    if (!options.yes) {
+        const shown = renderUndoPreview(previewed.view, preview);
+        if (io.ask === null) {
+            return shown;
+        }
+        // A person at a terminal answers here instead of re-running with --yes.
+        io.out(`${shown.text}\n`);
+        const reply = await io.ask(`${preview.cancels ? "Cancel" : "Undo"} it now? [y/N] `);
+        if (!/^y(es)?$/i.test(reply.trim())) {
+            return { text: "Not undone: nothing changed.\n", exitCode: 0 };
+        }
+        // The person's time to answer isn't the wait's.
+        startedAt = io.now().getTime();
+    }
+    const result = await undo(session, previewed.view.ref, true);
+    if (result.kind === "refused") {
+        return renderRefusal(result, { typedFile: null, retry: retryCommand(options), uploaded: false });
+    }
+    const view = result.view.state === "undoing" ? await waitFor(session, result.view, io, startedAt) : result.view;
+    if (view.state === "undone") {
+        return { text: `${undoneLine(view, preview.cancels ? null : preview.transactions)}\n`, exitCode: 0 };
+    }
+    // Back where it started: Driggsby couldn't finish the undo, and removed
+    // nothing.
+    if (view.state === "done" || view.state === "waiting") {
+        return refused(`Not undone: Driggsby couldn't finish undoing it just now, and nothing was removed.\n\nNext:\n  ${retryCommand(options)}\n`);
+    }
+    return renderStatus(view, { compact: false, repeated: false, unchanged: false, rerun: { file: null, account: null, create: null } }, context(io));
+}
+// Polls until something an agent acts on: the transactions are in, a
+// question, a stop, the end of an undo, or (for a wait that began while
+// categories filled in) the end of categorizing. Never past WAIT_MS from
+// startedAt.
+export async function waitFor(session, view, io, startedAt) {
+    const startedIn = view.state;
+    const deadline = startedAt + WAIT_MS;
+    let current = view;
+    while (!settled(current, startedIn) && io.now().getTime() + POLL_MS <= deadline) {
+        await io.sleep(POLL_MS);
+        // A busy moment, a server error or a lost connection mid-wait ends the
+        // wait where it stands; its output names the same command to run again.
+        const outcome = await findByRef(session, current.ref).catch((error) => {
+            if (error instanceof CliError && SIGNED_OUT.has(error.message))
+                throw error;
+            return null;
+        });
+        if (outcome?.kind !== "import") {
+            break;
+        }
+        current = outcome.view;
+    }
+    return current;
+}
+function settled(view, startedIn) {
+    switch (view.state) {
+        case "waiting":
+        case "done":
+        case "stopped":
+        case "undone":
+            return true;
+        case "categorizing":
+            return startedIn !== "categorizing";
+        default:
+            return false;
+    }
+}
+function renderRefusal(outcome, where) {
+    const ref = outcome.view?.ref ?? null;
+    const message = outcome.message;
+    if (outcome.code === "not_found") {
+        return refused(`Refused: there's no import with that ID on your account.\n\nNext, to see your imports:\n  ${CLI} import list\n`);
+    }
+    // A new account's name another account has: import into that one by its
+    // ID (its kind said, since it may not be the kind asked for), or name the
+    // new one differently.
+    if (outcome.code === "account_name_taken") {
+        if (outcome.account === null) {
+            return refused(`Refused: ${message} Nothing was imported.\n\nNext, to see where that import stands:\n  ${CLI} import list\n`);
+        }
+        const file = where.typedFile ?? "<FILE>";
+        const kind = kindWord(outcome.account.type);
+        return refused(`Refused: ${message} Nothing was imported.\n\n` +
+            `Next, to import into ${kind === "" ? "it" : `that ${kind} account`}:\n  ${CLI} import ${file} --account ${outcome.account.ref}\n` +
+            `Or into a new account by another name:\n  ${CLI} import ${file} --create-account --account-type ${where.create?.type ?? "card"} --account-name "<NAME>"\n`);
+    }
+    if (ACCOUNT_REFUSALS.has(outcome.code)) {
+        return refused(`Refused: ${message} Nothing was imported.\n\nNext, to see your accounts and their IDs:\n  ${CLI} accounts list\n`);
+    }
+    if (outcome.code === "already_imported" && ref !== null) {
+        return refused(`Refused: ${message}\n\nNext, to undo it first:\n  ${CLI} import undo ${ref}\n`);
+    }
+    // Another send of this file was in flight; the same command again finds
+    // where it stands, or starts it afresh.
+    if (outcome.code === "already_imported") {
+        return refused(`Refused: ${message} Nothing was imported.\n\nNext, run the same command again:\n  ${where.retry}\n`);
+    }
+    if (outcome.code === "wrong_answer" && outcome.view !== null) {
+        return refused(`Refused: ${message}\n\n${renderQuestion(outcome.view)}`);
+    }
+    if (outcome.code === "busy" || outcome.code === "account_still_importing") {
+        return refused(`Refused: ${message}\n\nNext, once that's done:\n  ${where.retry}\n`);
+    }
+    // An undo another change beat: where the import stands now says what's next.
+    if (outcome.code === "not_undoable" && ref !== null) {
+        return refused(`Refused: ${message}\n\nNext, to see where it stands:\n  ${CLI} import ${ref}\n`);
+    }
+    return refused(`Refused: ${message}${where.uploaded ? " Nothing was imported." : ""}\n`);
+}
+function refused(text) {
+    return { text, exitCode: 1 };
+}
+function answerGiven(options) {
+    if (options.dates !== null)
+        return { dates: options.dates };
+    if (options.amounts !== null)
+        return { amounts: options.amounts };
+    return null;
+}
+// The account the command names, if it names one.
+function named(options) {
+    if (options.account !== null)
+        return { account: options.account };
+    if (options.create !== null)
+        return { create: options.create };
+    return null;
+}
+// The account a new file goes in, or the commands that name one: an import
+// always names its account, and Driggsby never picks one.
+function destination(options, file) {
+    const chosen = named(options);
+    if (chosen !== null)
+        return chosen;
+    throw new CliError(`error: name the account this statement goes in, one you have or a new one:\n` +
+        `  ${CLI} import ${file} --account <ID>\n` +
+        `  ${CLI} import ${file} --create-account --account-type card --account-name "<NAME>"\n\n` +
+        `Your accounts and their IDs:\n  ${CLI} accounts list`, 2);
+}
+function context(io) {
+    return io.timeZone === undefined ? { now: io.now() } : { now: io.now(), timeZone: io.timeZone };
+}
+// The command as given, so a retry lands exactly where the first try aimed:
+// an account named on the first try is named again.
+function retryCommand(options) {
+    if (options.action === "list")
+        return `${CLI} import list`;
+    if (options.action === "accounts")
+        return `${CLI} accounts list`;
+    if (options.action === "undo")
+        return `${CLI} import undo ${shellWord(options.target)}${options.yes ? " --yes" : ""}`;
+    const flags = [
+        accountFlags(options.account, options.create),
+        options.dates === null ? "" : ` --dates ${options.dates}`,
+        options.amounts === null ? "" : ` --amounts ${options.amounts}`,
+        options.wait ? " --wait" : "",
+    ].join("");
+    return `${CLI} import ${shellWord(options.target)}${flags}`;
+}

package/dist/import/import-render.js

@@ -0,0 +1,334 @@
+// What the import command prints. Every output follows one contract, so an
+// agent with no Driggsby context never has to guess: the first line says
+// where things stand ("Started:", "Waiting for an answer:", "Done:", ...)
+// and is never wrapped, and the last lines give the exact command to run
+// next, complete, with one command per answer when the person must choose.
+// Names Driggsby sends (a file, an account) print quoted and capped, so they
+// read as names and never as the CLI's own sentence.
+import { formatBytes } from "@driggsby/deploy";
+import { capForTerminal, quotedForTerminal, wrapProse } from "../terminal-text.js";
+import {} from "./import-client.js";
+import {} from "./import-view.js";
+export const CLI = "npx driggsby@latest";
+const NAME_CHARS = 120;
+const MESSAGE_CHARS = 1_000;
+export const ASK = "If you're working for someone, ask them; don't guess. Nothing lands until it's answered.";
+// A stop whose fix is another account, not the same command again.
+const ACCOUNT_STOPS = new Set(["account_not_found", "account_mismatch"]);
+const TYPE_WORDS = { credit: "card", depository: "bank" };
+const EXPLAIN = {
+    date_order: "Every date in it reads either way, like 03/04/2026.",
+    amount_direction: "It doesn't say which way its amounts go.",
+};
+const NOTHING_NEW = {
+    all_duplicates: "all of its transactions were already in Driggsby",
+    all_covered_by_link: "the bank link already brought in all of its transactions",
+    all_pending: "all of its transactions are still pending; import it again once they post",
+};
+const name = (value) => quotedForTerminal(value, NAME_CHARS);
+const said = (value) => capForTerminal(value, MESSAGE_CHARS).trim();
+const next = (...commands) => `Next:\n${commands.map((command) => `  ${command}`).join("\n")}\n`;
+const waitCommand = (ref) => `${CLI} import ${ref} --wait`;
+const indented = (text) => wrapProse(text, 74)
+    .split("\n")
+    .map((line) => `  ${line}`)
+    .join("\n");
+export function renderStarted(view) {
+    const size = view.lines === null ? "" : `${plural(view.lines, "line")}${view.bytes === null ? "" : `, ${formatBytes(view.bytes)}`}`;
+    return ok(`Started: importing ${name(view.file)} as ${view.ref}.\n\n` +
+        (size === "" ? "" : `✓ Uploaded    ${size}\n\n`) +
+        `${wrapProse("Driggsby is reading it now, which usually takes under a minute. Nothing lands in your accounts until it finishes.")}\n\n` +
+        next(waitCommand(view.ref)));
+}
+export function renderStatus(view, options, context) {
+    const body = statusBody(view, options, context);
+    if (!options.unchanged) {
+        return body;
+    }
+    // The first line still says where things stand; the note comes after it.
+    const [first = "", ...rest] = body.text.split("\n\n");
+    return { text: [first, "Nothing changed: this import isn't waiting for an answer.", ...rest].join("\n\n"), exitCode: body.exitCode };
+}
+function statusBody(view, options, context) {
+    switch (view.state) {
+        case "reading":
+        case "importing": {
+            const doing = view.state === "reading" ? "Still reading" : "Still importing";
+            return ok(`${doing}: ${name(view.file)}, started ${ago(view.startedAt, context.now)}.\n\n` +
+                `${wrapProse("Some files take a few minutes. Nothing lands until it finishes.")}\n\n${next(waitCommand(view.ref))}`);
+        }
+        case "waiting":
+            return ok(renderQuestion(view));
+        case "categorizing":
+            return ok(options.compact ? categorizingLine(view) : landed(view, "Imported"));
+        case "done":
+            return ok(done(view, options, context));
+        case "stopped":
+            return { text: `Stopped: ${name(view.file)} wasn't imported. Nothing landed.\n\n${wrapProse(said(view.stopped?.message ?? ""))}\n\n${rerun(view, options)}`, exitCode: 1 };
+        case "undoing":
+            return ok(`${undoingLine(view)}\n\n${next(waitCommand(view.ref))}`);
+        case "undone":
+            return ok(`${undoneLine(view, null)}\n`);
+    }
+}
+// A cancel landed nothing, so it removes nothing either.
+function undoingLine(view) {
+    return view.counts === null
+        ? `Undoing: cancelling ${name(view.file)}; nothing of it had landed.`
+        : `Undoing: removing the transactions ${name(view.file)} added.`;
+}
+// Importing the file again, aimed where the first try was; a stop about the
+// account starts from the account list instead.
+function rerun(view, options) {
+    if (ACCOUNT_STOPS.has(view.stopped?.code ?? "")) {
+        return `Next, to see your accounts and their IDs:\n  ${CLI} accounts list\n`;
+    }
+    const flags = accountFlags(options.rerun.account, options.rerun.create);
+    if (options.rerun.file !== null && flags !== "") {
+        return next(`${CLI} import ${options.rerun.file}${flags}`);
+    }
+    // Looked up by ID: the account it was for may be one it was making.
+    const file = options.rerun.file ?? "<FILE>";
+    return (`Next, with the same file, into one of your accounts or a new one:\n  ${CLI} import ${file} --account <ID>\n` +
+        `  ${CLI} import ${file} --create-account --account-type card --account-name "<NAME>"\n`);
+}
+// The account flags as typed: an ID, or the new account's type and name
+// (always quoted for a POSIX shell).
+export function accountFlags(account, create) {
+    if (account !== null)
+        return ` --account ${account}`;
+    if (create !== null)
+        return ` --create-account --account-type ${create.type} --account-name ${quotedName(create.name)}`;
+    return "";
+}
+export function quotedName(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+// An account's kind in the words the flags use (card, bank), or as Driggsby
+// names it.
+export function kindWord(type) {
+    return TYPE_WORDS[type] ?? capForTerminal(type, 20);
+}
+// Each account with its kind and the ID an import names, then how to import.
+export function renderAccounts(rows) {
+    const create = `${CLI} import <FILE> --create-account --account-type card --account-name "<NAME>"`;
+    if (rows.length === 0) {
+        return ok(`No accounts yet.\n\nNext, to import a statement into a new account:\n  ${create}\n`);
+    }
+    const lines = rows.map((row) => {
+        const label = name(row.last4 === null ? row.name : `${row.name} ····${row.last4}`);
+        return `  ${label}\n    ${kindWord(row.type)} · ${row.ref}`;
+    });
+    return ok(`Your accounts (${String(rows.length)}):\n${lines.join("\n")}\n\n` +
+        `Next, to import a statement into one:\n  ${CLI} import <FILE> --account <ID>\nOr into a new account:\n  ${create}\n`);
+}
+export function renderQuestion(view) {
+    const question = view.question;
+    const prompt = question === null ? "What does Driggsby need to know?" : said(question.prompt);
+    const explain = question === null ? "" : (EXPLAIN[question.kind] ?? "");
+    const asked = indented(`${explain === "" ? "" : `${explain} `}${ASK}`).replace(/^ {2}/, "? ");
+    const choices = question?.choices ?? [];
+    const answers = choices.length === 0
+        ? next(`${CLI} import ${view.ref}`)
+        : `Next, run the command for the answer:\n${choiceLines(choices, (choice) => `${CLI} import ${view.ref} ${choice.flag} ${choice.value} --wait`)}`;
+    return `Waiting for an answer about ${name(view.file)}: ${prompt}\n\n${asked}\n\n${answers}`;
+}
+export function choiceLines(choices, command) {
+    return `${choices.map((choice) => `  ${name(choice.label)}\n    ${command(choice)}`).join("\n")}\n`;
+}
+// The transactions are in: what landed, then what's left to do.
+function landed(view, headline) {
+    const where = view.account === null ? " landed" : ` are in ${name(view.account)}`;
+    const top = `${headline}: ${plural(view.counts?.new ?? 0, "transaction")} from ${name(view.file)}${where}.`;
+    const undoCommand = `  ${CLI} import undo ${view.ref}\n`;
+    // A new account is the person's to name by its ID from here on.
+    const again = view.newAccount && view.accountRef !== null ? `Next time, for this account:\n  ${CLI} import <FILE> --account ${view.accountRef}\n\n` : "";
+    const tail = again +
+        (headline === "Imported"
+            ? `${wrapProse("The transactions are usable now, and categories fill in on their own. Nothing else to do unless you need the categories (for a spending summary, say). To wait for them:")}\n` +
+                `  ${waitCommand(view.ref)}\n\nIf it went into the wrong account, undo it once categories finish:\n${undoCommand}`
+            : `${wrapProse("Nothing else to do: the import is finished. If it went into the wrong account, undo it with:")}\n${undoCommand}`);
+    return `${top}\n\n${details(view, headline)}\n${tail}`;
+}
+function details(view, headline) {
+    const rows = [];
+    if (view.lines !== null) {
+        rows.push(`✓ Read        ${plural(view.lines, "line")}${view.dates === null ? "" : `, ${dateRange(view.dates.from, view.dates.to)}`}`);
+    }
+    if (view.account !== null) {
+        rows.push(`✓ Account     ${name(view.account)}${view.newAccount ? " (a new account)" : ""}`);
+    }
+    if (view.counts !== null) {
+        const already = view.counts.alreadyInDriggsby;
+        rows.push(`✓ Imported    ${view.counts.new.toLocaleString("en-US")} new${already > 0 ? ` · ${already.toLocaleString("en-US")} already in Driggsby, skipped` : ""}`);
+    }
+    rows.push(headline === "Imported" ? `● Categories  ${progressText(view)}` : categoriesDone(view));
+    const leftOut = leftOutText(view);
+    if (leftOut !== "") {
+        rows.push(`· Left out    ${leftOut}`);
+    }
+    return `${rows.join("\n")}\n`;
+}
+function categoriesDone(view) {
+    return view.categorized === false
+        ? "· Categories  some couldn't be filled in; those show as uncategorized"
+        : `✓ Categories  all ${(view.counts?.new ?? 0).toLocaleString("en-US")} categorized`;
+}
+function progressText(view) {
+    const progress = view.progress;
+    if (progress === null || progress.categorized === 0) {
+        return "starting now";
+    }
+    const left = progress.secondsLeft === null ? "" : `, ${timeLeft(progress.secondsLeft)}`;
+    return `${progress.categorized.toLocaleString("en-US")} of ${progress.total.toLocaleString("en-US")} so far${left}`;
+}
+function categorizingLine(view) {
+    const progress = view.progress;
+    const where = progress === null || progress.categorized === 0
+        ? "categorizing has started"
+        : `${progress.categorized.toLocaleString("en-US")} of ${plural(progress.total, "transaction")} so far${progress.secondsLeft === null ? "" : `, ${timeLeft(progress.secondsLeft)}`}`;
+    return `Categorizing: ${where}.\n\nThe transactions are usable while this runs.\n\n${next(waitCommand(view.ref))}`;
+}
+function done(view, options, context) {
+    if (view.nothingNew !== null) {
+        const why = NOTHING_NEW[view.nothingNew] ?? "none of its transactions were new";
+        return `Done: nothing new in ${name(view.file)}: ${why}.\n\nNothing else to do.\n`;
+    }
+    // A wait that followed categorizing ends on how it went, even for a file
+    // sent again.
+    if (options.compact && view.categorized === false) {
+        return (`Done: ${plural(view.counts?.new ?? 0, "transaction")} from ${name(view.file)} are in, but some couldn't be categorized.\n\n` +
+            `${wrapProse("Those show as uncategorized. Nothing else to do: the import is finished.")}\n`);
+    }
+    if (options.compact) {
+        return `Done: all ${plural(view.counts?.new ?? 0, "transaction")} from ${name(view.file)} are categorized.\n\nNothing else to do: the import is finished.\n`;
+    }
+    if (options.repeated) {
+        const on = view.finishedAt === null ? "" : ` on ${shortDate(view.finishedAt, context)}`;
+        const into = view.account === null ? " landed" : ` went into ${name(view.account)}`;
+        return `Already done: this file's ${plural(view.counts?.new ?? 0, "transaction")}${into}${on} (${view.ref}). Nothing to do.\n`;
+    }
+    return landed(view, "Done");
+}
+export function undoneLine(view, removed) {
+    if (view.counts === null) {
+        return `Undone: ${name(view.file)} was cancelled before anything landed, and its file is deleted.`;
+    }
+    const what = removed === null ? "the transactions it added are gone" : `removed ${plural(removed, "transaction")}`;
+    return `Undone: ${name(view.file)}: ${what}${view.account === null ? "" : ` from ${name(view.account)}`}.`;
+}
+// Undo asked for while it can't run yet, or after it already has: where
+// things stand and, when there's a wait, the commands in order. Not a
+// failure: repeating an undo is safe.
+export function renderNotUndoable(view, preview) {
+    switch (view.state) {
+        case "undone":
+            return ok(`Already undone: nothing ${name(view.file)} added is left.\n`);
+        case "undoing":
+            return ok(`${undoingLine(view)}\n\n${next(waitCommand(view.ref))}`);
+        case "stopped":
+            return ok(`Nothing to undo: ${name(view.file)} stopped before anything landed.\n`);
+        case "reading":
+        case "importing":
+        case "categorizing":
+            return ok(`Not undone yet: ${name(view.file)} is still ${view.state}, and undo works once that finishes.\n\n` +
+                `Next, run the first until it says Done or asks a question, then the second:\n  ${waitCommand(view.ref)}\n  ${CLI} import undo ${view.ref}\n`);
+        default:
+            return { text: `Refused: ${said(preview.message ?? "This import can't be undone right now.")}\n`, exitCode: 1 };
+    }
+}
+export function renderUndoPreview(view, preview) {
+    const yes = `${CLI} import undo ${view.ref} --yes`;
+    if (preview.cancels) {
+        return ok(`Not undone yet: ${name(view.file)} is still waiting for an answer, so nothing has landed.\n\n` +
+            `${indented("Undoing cancels it and deletes its uploaded file.")}\n\nNext, to cancel it:\n  ${yes}\n`);
+    }
+    const edited = preview.edited > 0 ? `, and ${preview.edited} ${preview.edited === 1 ? "was" : "were"} edited since` : "";
+    const parts = [
+        `They're the transactions it added${view.account === null ? "" : ` to ${name(view.account)}`}${edited}.`,
+        preview.edited > 0 ? "Importing the file again brings the transactions back, but not those edits." : "Importing the file again brings them back.",
+        preview.accountRemoved ? "The account it made goes too, since nothing else is in it." : "",
+        preview.keptForLaterImports > 0 ? `${plural(preview.keptForLaterImports, "transaction")} stay, since a later import found them too.` : "",
+        "If you're working for someone, check with them first.",
+    ].filter((part) => part !== "");
+    return ok(`Not undone yet: undoing ${name(view.file)} would remove ${plural(preview.transactions, "transaction")}.\n\n${indented(parts.join(" "))}\n\n` +
+        `Next, to undo it:\n  ${yes}\n`);
+}
+export function renderList(views, context) {
+    if (views.length === 0) {
+        return ok(`You haven't imported any statements yet.\n\n${next(`${CLI} import <FILE>`)}`);
+    }
+    const rows = views.map((view) => ({ ref: view.ref, state: listState(view), file: quotedForTerminal(view.file, 40), date: shortDate(view.startedAt, context) }));
+    const stateWidth = Math.max(...rows.map((row) => row.state.length));
+    const fileWidth = Math.max(...rows.map((row) => row.file.length));
+    const table = rows.map((row) => `  ${row.ref}  ${row.state.padEnd(stateWidth)}  ${row.file.padEnd(fileWidth)}  ${row.date}`.trimEnd()).join("\n");
+    const waiting = views.filter((view) => view.state === "waiting");
+    const attention = waiting.length === 0 ? "" : `\nNeeds attention:\n${waiting.map((view) => `  ${CLI} import ${view.ref}`).join("\n")}\n`;
+    return ok(`Your recent imports, newest first:\n\n${table}\n${attention}`);
+}
+function listState(view) {
+    switch (view.state) {
+        case "waiting":
+            return "waiting for an answer";
+        case "categorizing":
+            return view.progress === null ? "categorizing" : `categorizing, ${view.progress.categorized}/${view.progress.total}`;
+        case "done":
+            return view.nothingNew !== null ? "done, nothing new" : `done, ${view.counts?.new ?? 0} new`;
+        default:
+            return view.state;
+    }
+}
+function leftOutText(view) {
+    const pending = (view.counts?.pending ?? 0) + view.leftOut.notPosted;
+    return [
+        pending > 0 ? plural(pending, "pending charge") : "",
+        view.leftOut.balance > 0 ? plural(view.leftOut.balance, "balance line") : "",
+        view.leftOut.unreadable > 0 ? plural(view.leftOut.unreadable, "unreadable line") : "",
+    ]
+        .filter((part) => part !== "")
+        .join(" · ");
+}
+export function plural(count, noun) {
+    return `${count.toLocaleString("en-US")} ${noun}${count === 1 ? "" : "s"}`;
+}
+function ok(text) {
+    return { text, exitCode: 0 };
+}
+function timeLeft(seconds) {
+    if (seconds < 60)
+        return "under a minute left";
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 90)
+        return `about ${minutes} ${minutes === 1 ? "minute" : "minutes"} left`;
+    return `about ${Math.round(minutes / 60)} hours left`;
+}
+function ago(iso, now) {
+    const started = iso === null ? Number.NaN : Date.parse(iso);
+    if (Number.isNaN(started))
+        return "a moment ago";
+    const seconds = Math.max(0, Math.round((now.getTime() - started) / 1000));
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s ago`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m ago`;
+}
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+// Statement dates are calendar dates (YYYY-MM-DD), read without a zone.
+function dateRange(from, to) {
+    const [fromYear, fromMonth, fromDay] = from.split("-").map(Number);
+    const [toYear, toMonth, toDay] = to.split("-").map(Number);
+    if ([fromYear, fromMonth, fromDay, toYear, toMonth, toDay].some((part) => part === undefined || Number.isNaN(part)))
+        return "";
+    const day = (month, dayOfMonth) => `${MONTHS[(month ?? 1) - 1] ?? ""} ${String(dayOfMonth)}`;
+    return fromYear === toYear
+        ? `${day(fromMonth, fromDay)} – ${day(toMonth, toDay)}, ${String(toYear)}`
+        : `${day(fromMonth, fromDay)}, ${String(fromYear)} – ${day(toMonth, toDay)}, ${String(toYear)}`;
+}
+function shortDate(iso, context) {
+    const at = iso === null ? Number.NaN : Date.parse(iso);
+    if (Number.isNaN(at))
+        return "";
+    return new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric", timeZone: context.timeZone }).format(new Date(at));
+}