@wirecat/cli-core 0.548.0 → 0.549.0

package/dist/cli/compact.js

@@ -0,0 +1,313 @@
+import { visibleControls } from "@wirecat/cli-base";
+import { metaOf } from "@wirecat/cli-base/commands";
+import { ENTITIES } from "../entities/index.js";
+import { answerRow } from "./answer-entity.js";
+export const TEXT_CHARS = 400;
+const sender = { field: ["sender_is_me", "sender_name"], tag: "me" };
+const messageRow = {
+    columns: [
+        { field: "ref" },
+        { field: "timestamp", as: "time" },
+        { field: "chat_title" },
+        sender,
+        { field: ["reply_to_id", "reply_to.id"], as: "reply" },
+        { field: "forwarded_from", as: "forward" },
+        { field: "attachments", as: "files" },
+    ],
+    text: ["text", "transcript", "excerpt"],
+};
+/** Rows for cli-core's shared entities. */
+export const SHARED_ROWS = {
+    message: messageRow,
+    "message.summary": messageRow,
+    "message.hit": {
+        columns: [
+            { field: "ref" },
+            { field: "timestamp", as: "time" },
+            { field: "chat_title" },
+            sender,
+            { field: "attachments", as: "files" },
+        ],
+        text: ["excerpt", "text"],
+    },
+    chat: {
+        columns: [
+            { field: "ref" },
+            { field: "title" },
+            { field: "kind" },
+            { field: "unread_count", as: "count", tag: "unread" },
+            { field: "last_message_at", as: "time" },
+        ],
+    },
+};
+/** Any record: what names it, what it is called, what state it is in, then what it says. */
+export const GENERIC_ROW = {
+    columns: [
+        { field: ["key", "ref", "id"] },
+        { field: ["title", "name", "path"] },
+        { field: ["state", "status", "due_at"] },
+    ],
+    text: ["text", "excerpt"],
+};
+/** The row an entity named in a section is drawn with: the app's, the shared one, else the generic one. */
+export const rowsOfEntity = (table = {}) => (entity) => (Object.hasOwn(table, entity) ? table[entity] : undefined) ?? SHARED_ROWS[entity] ?? GENERIC_ROW;
+const declaredNames = (command) => {
+    const output = command ? metaOf(command).output : undefined;
+    if (!output)
+        return [];
+    return output.view ? [`${output.entity}.${output.view}`, output.entity] : [output.entity];
+};
+/** An app's own rows by entity name, as `entityFields` takes its fields; a shared name is refused. */
+export const entityRows = (table) => {
+    const shared = Object.keys(table).filter((name) => name in ENTITIES || name in SHARED_ROWS);
+    if (shared.length > 0)
+        throw new Error(`entityRows: ${shared.join(", ")} is cli-core's entity; name yours apart`);
+    return (command) => {
+        const name = declaredNames(command).find((one) => Object.hasOwn(table, one));
+        return name === undefined ? undefined : table[name];
+    };
+};
+/** The row a command's answer is drawn with: its own, its app's, the shared one, else the generic one. */
+export const rowShapeOf = (command, resolve) => {
+    const own = answerRow(command) ?? resolve?.(command);
+    if (own)
+        return own;
+    const shared = declaredNames(command).find((name) => Object.hasOwn(SHARED_ROWS, name));
+    return shared === undefined ? GENERIC_ROW : SHARED_ROWS[shared];
+};
+const isFields = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const present = (value) => value !== null && value !== undefined && value !== "" && value !== false && !(Array.isArray(value) && !value.length);
+const at = (item, path) => path.split(".").reduce((value, key) => (isFields(value) ? value[key] : undefined), item);
+const fieldsOfColumn = (field) => (typeof field === "string" ? [field] : field);
+// A record or a list is not one value; a file list is the only column that reads one, by its own path.
+const printable = (value, column) => present(value) &&
+    (column?.as === "files" || column?.as === "forward" || column?.as === "reply" || !isListOrRecord(value));
+const isListOrRecord = (value) => typeof value === "object" && value !== null;
+const firstSet = (item, field, column) => fieldsOfColumn(field)
+    .map((path) => at(item, path))
+    .find((value) => printable(value, column));
+const sourceOf = (item, column) => fieldsOfColumn(column.field).find((path) => printable(at(item, path), column));
+// Whitespace runs become one space and control or direction characters show, so a text cannot start a row of its own.
+const clean = (text) => visibleControls(text.replace(/\s+/g, " ").trim());
+const cut = (text, chars) => {
+    if (chars <= 0)
+        return text;
+    const letters = Array.from(text);
+    return letters.length <= chars ? text : `${letters.slice(0, chars).join("")}…(+${letters.length - chars})`;
+};
+const clockFor = (zone) => {
+    const format = new Intl.DateTimeFormat("en-CA", {
+        timeZone: zone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23",
+    });
+    return {
+        zone,
+        parts: (iso) => {
+            const ms = Date.parse(iso);
+            if (Number.isNaN(ms))
+                return undefined;
+            const part = Object.fromEntries(format.formatToParts(ms).map(({ type, value }) => [type, value]));
+            return { date: `${part.year}-${part.month}-${part.day}`, time: `${part.hour}:${part.minute}` };
+        },
+    };
+};
+const duration = (seconds) => {
+    const whole = Math.round(seconds);
+    return `${Math.floor(whole / 60)}:${String(whole % 60).padStart(2, "0")}`;
+};
+const fileTag = (file) => {
+    if (!isFields(file))
+        return undefined;
+    const kind = typeof file.kind === "string" && file.kind !== "" ? file.kind : "file";
+    const extra = typeof file.duration === "number" ? duration(file.duration) : typeof file.name === "string" ? file.name : "";
+    return `[${clean(extra ? `${kind} ${extra}` : kind)}]`;
+};
+const cellOf = (item, column, clock) => {
+    const value = firstSet(item, column.field, column);
+    if (!present(value))
+        return undefined;
+    switch (column.as) {
+        case "time":
+        case "day": {
+            if (typeof value !== "string")
+                return undefined;
+            const parts = clock.parts(value);
+            if (!parts)
+                return { text: clean(value) };
+            const day = parts.date.slice(5);
+            return { text: column.as === "day" ? day : `${day} ${parts.time}`, date: parts.date };
+        }
+        case "count":
+            return typeof value === "number" && value !== 0
+                ? { text: column.tag ? `${value} ${column.tag}` : String(value) }
+                : undefined;
+        case "files": {
+            const tags = (Array.isArray(value) ? value : [value]).map(fileTag).filter((tag) => tag !== undefined);
+            return tags.length ? { text: tags.join(" ") } : undefined;
+        }
+        case "reply": {
+            const id = isFields(value) ? value.id : value;
+            return typeof id === "string" || typeof id === "number" ? { text: `↳#${clean(String(id))}` } : undefined;
+        }
+        case "forward": {
+            const name = isFields(value) ? value.sender_name : value;
+            return { text: typeof name === "string" && name !== "" ? `↪ ${clean(name)}` : "↪" };
+        }
+        default:
+            if (value === true)
+                return column.tag ? { text: column.tag } : undefined;
+            if (typeof value === "string" || typeof value === "number")
+                return { text: clean(String(value)) };
+            return undefined;
+    }
+};
+const textOf = (item, shape, chars) => {
+    const value = (shape.text ?? [])
+        .map((field) => at(item, field))
+        .find((one) => typeof one === "string" && present(one));
+    return typeof value === "string" ? cut(clean(value), chars) : undefined;
+};
+// A line that starts with "# " is the answer's own; a row is shifted so that no item can pass for one.
+const guarded = (line) => (line.startsWith("#") && !/^#[^\s#]/.test(line) ? `\\${line}` : line);
+const REF = /^[a-z]+:\S*\/[^/\s]+$/;
+/** The shared part of the refs up to their last `/`, when every row has one and there is more than one row. */
+const sharedPrefix = (refs) => {
+    if (refs.length < 2 || !refs.every((ref) => ref !== undefined && REF.test(ref)))
+        return undefined;
+    const prefixes = new Set(refs.map((ref) => ref.slice(0, ref.lastIndexOf("/") + 1)));
+    return prefixes.size === 1 ? [...prefixes][0] : undefined;
+};
+const span = (dates) => {
+    if (!dates.length)
+        return undefined;
+    const sorted = [...dates].sort();
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    return first === last ? first : `${first}…${last}`;
+};
+// A column every row prints the same, a chat's title in a list of its messages, is said once in the header.
+const sameEverywhere = (rows, index) => {
+    const first = rows[0]?.cells[index]?.text;
+    return first !== undefined && rows.every(({ cells }) => cells[index]?.text === first);
+};
+const rowsOfItems = (items, shape, clock, chars) => {
+    const dates = [];
+    const rows = items.map((item) => {
+        if (!isFields(item))
+            return { cells: [], text: clean(String(item)) };
+        const cells = shape.columns.map((column) => cellOf(item, column, clock));
+        for (const cell of cells)
+            if (cell?.date)
+                dates.push(cell.date);
+        return { cells, text: textOf(item, shape, chars), item };
+    });
+    const firstColumn = shape.columns[0];
+    const refs = rows.map(({ item }) => item && firstColumn ? firstSet(item, firstColumn.field) : undefined);
+    const prefix = sharedPrefix(refs.map((ref) => (typeof ref === "string" ? ref : undefined)));
+    const hoisted = rows.length < 2 ? [] : shape.columns.map((_, index) => index > 0 && sameEverywhere(rows, index));
+    const named = hoisted.flatMap((hoist, index) => {
+        const column = shape.columns[index];
+        const item = rows[0]?.item;
+        if (!hoist || !column || !item)
+            return [];
+        return [`${sourceOf(item, column) ?? fieldsOfColumn(column.field)[0]}: ${rows[0]?.cells[index]?.text}`];
+    });
+    const lines = rows.map(({ cells, text, item }) => {
+        const parts = cells.map((cell, index) => (hoisted[index] ? undefined : cell?.text));
+        const shortened = prefix ? clean(prefix) : undefined;
+        if (shortened && parts[0]?.startsWith(shortened))
+            parts[0] = `#${parts[0].slice(shortened.length)}`;
+        const shown = [...parts, text].filter((part) => part !== undefined && part !== "");
+        return guarded(shown.length ? shown.join(" · ") : item ? blockLine(item, chars) : "");
+    });
+    const when = span(dates);
+    const header = [...(prefix ? [`ref: ${clean(prefix)}<id>`] : []), ...named, ...(when ? [when, clock.zone] : [])];
+    return { header, lines };
+};
+const blockLine = (fields, chars) => blockOf(fields, chars).join("  ");
+/** A record as `field: value` lines; a nested record is indented under its field, a list of records counted. */
+const blockOf = (fields, chars, indent = "") => Object.entries(fields)
+    .filter(([name]) => !(name === "priority" && "priority_label" in fields))
+    .filter(([, value]) => present(value) || value === false)
+    .flatMap(([name, value]) => {
+    const label = `${indent}${clean(name)}:`;
+    if (isFields(value))
+        return [label, ...blockOf(value, chars, `${indent}  `)];
+    if (Array.isArray(value))
+        return value.every((one) => !isFields(one) && !Array.isArray(one))
+            ? [`${label} ${cut(clean(value.join(", ")), chars)}`]
+            : [`${label} ${value.length} — --json shows them`];
+    return [`${label} ${cut(clean(String(value)), chars)}`];
+});
+const footerOf = (body) => {
+    const lines = [];
+    const steps = body.next ?? [];
+    const lineOf = (step) => (step.kind === "command" ? (step.line ?? step.command) : undefined);
+    if ("items" in body && body.page.has_more) {
+        const more = steps.find((step) => step.step === "page.next");
+        const line = more?.kind === "command" ? more.line : undefined;
+        const page = body.page;
+        lines.push(`# more: ${clean(line ??
+            (page.mode === "cursor" && page.next_cursor
+                ? `--cursor ${page.next_cursor}`
+                : page.mode === "page" && page.next_page
+                    ? `--page ${page.next_page}`
+                    : "raise --limit"))}`);
+    }
+    for (const missing of body.missing ?? [])
+        lines.push(`# missing: ${clean(missing.field)}: ${clean(missing.why)}`);
+    for (const step of steps) {
+        if (step.step === "page.next" && "items" in body)
+            continue;
+        const line = lineOf(step);
+        lines.push(`# next: ${clean(step.why)}${line ? `: ${clean(line)}` : ""}`);
+    }
+    if (body.meta?.complete === false) {
+        const issues = (body.meta.issues ?? []).map((issue) => `${clean(issue.source)}: ${clean(String(issue.code))}`);
+        lines.push(`# complete: false${issues.length ? ` (${issues.join(", ")})` : ""}`);
+    }
+    if (body.meta?.truncated)
+        lines.push("# truncated: true");
+    return lines;
+};
+const usableZone = (zone) => {
+    if (!zone)
+        return undefined;
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: zone });
+        return zone;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** The whole answer as compact text: header, rows, footer. Pure: no store, no clock. */
+export const compactText = (body, shape, options, rowsOf = rowsOfEntity()) => {
+    const clock = clockFor(usableZone(body.meta?.timezone) ?? usableZone(options.timezone) ?? "UTC");
+    const chars = options.textChars ?? TEXT_CHARS;
+    let lines = [];
+    if ("items" in body) {
+        const { header, lines: rows } = rowsOfItems(body.items, shape, clock, chars);
+        lines = (header.length ? [`# ${header.join(" · ")}`] : []).concat(rows.length ? rows : ["# nothing found"]);
+    }
+    else if (isFields(body.item)) {
+        const sections = shape.sections ?? {};
+        const rest = Object.fromEntries(Object.entries(body.item).filter(([name]) => !Object.hasOwn(sections, name)));
+        lines = blockOf(rest, chars).map(guarded);
+        for (const [name, entity] of Object.entries(sections)) {
+            const list = body.item[name];
+            if (!Array.isArray(list))
+                continue;
+            const { header, lines: rows } = rowsOfItems(list, rowsOf(entity), clock, chars);
+            lines = lines.concat([`# ${[`${clean(name)}: ${list.length}`, ...header].join(" · ")}`], rows);
+        }
+    }
+    else if (present(body.item))
+        lines = [guarded(cut(clean(String(body.item)), chars))];
+    return lines.concat(footerOf(body)).join("\n");
+};

package/dist/cli/context.d.ts

@@ -1,6 +1,6 @@
 import { type KeyringStore, type Renderer, type RenderFormat, type Streams } from "@wirecat/cli-base";
-import type { ErrorObject } from "@wirecat/cli-base/standards";
-import type { Command } from "commander";
+import { type ErrorObject } from "@wirecat/cli-base/standards";
+import { type Command } from "commander";
 import { type Deadline, type RunBudget } from "../background/budget.js";
 import type { MessageEvent } from "../domain/models.js";
 import type { AppIdentity } from "../ports/app.js";
@@ -13,6 +13,8 @@ import { type Closeable } from "./deadline.js";
 import { type GlobalFlags, type ResolveOptions, type Settings } from "./settings.js";
 /** What every CLI's commands write to, when it is not the real terminal. A CLI adds its own fields. */
 export interface BaseEnvironment {
+    /** The app's own compact rows (`ProgramDefinition.rows`), for `renderAnswer`. */
+    rows?: import("./compact.js").RowTable;
     discoveryAvailability?: (command: import("./command-availability.js").AvailabilityCommand) => import("./command-availability.js").CommandAvailability | undefined;
     streams?: Streams;
     /** Whether a person is looking. Defaults to whether stdout is a terminal. */
@@ -121,12 +123,16 @@ export declare const environmentOf: <E extends BaseEnvironment = BaseEnvironment
  * output goes and a test that captures it sees it. `readSecret(prompt, { ...secretInputOf(this), echo: true })`.
  */
 export declare const secretInputOf: (command: Command) => Pick<SecretInput, "input" | "output">;
+/** Whether the run asked for one line per item (WC-OUT-24). */
+export declare const compactOf: (command: Command) => boolean;
 /** For the commands that print but never need settings or a connection. */
 export declare const outputFor: (command: Command) => {
     format: "json" | "jsonl" | "pretty";
     color: boolean;
     streams: Streams;
     renderer: Renderer;
+    compact?: boolean | undefined;
+    full?: boolean | undefined;
 };
 export interface BaseContext {
     settings: Settings;
@@ -135,6 +141,9 @@ export interface BaseContext {
     /** Whether the human view may use colour — for views that print their own text. */
     color: boolean;
     streams: Streams;
+    /** One line per item; `renderAnswer` draws it, `full` keeps each text whole. */
+    compact?: boolean;
+    full?: boolean;
     env: NodeJS.ProcessEnv;
     keyring?: KeyringStore;
     /**

package/dist/cli/context.js

@@ -1,5 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { metaOf } from "@wirecat/cli-base/commands";
+import { COMPACT_FLAG } from "@wirecat/cli-base/standards";
+import { Option } from "commander";
 import { runBudget } from "../background/budget.js";
 import { resolveOutput } from "../output.js";
 import { recorded } from "../runs/recording.js";
@@ -43,22 +45,27 @@ export const secretInputOf = (command) => {
     const { stdin, stderr } = environmentOf(command);
     return { ...(stdin ? { input: stdin } : {}), ...(stderr ? { output: stderr } : {}) };
 };
+const detailOf = ({ brief, full }) => {
+    if (brief && full)
+        throw new CliError("validation_error", "--brief and --full ask for opposite things — pick one");
+    return brief ? { hitDetail: "brief" } : full ? { hitDetail: "full" } : {};
+};
+const COMPACT_KEY = new Option(COMPACT_FLAG).attributeName();
+/** Whether the run asked for one line per item (WC-OUT-24). */
+export const compactOf = (command) => command.optsWithGlobals()[COMPACT_KEY] === true;
 /** For the commands that print but never need settings or a connection. */
 export const outputFor = (command) => {
     const { streams, tty, env, agent } = environmentOf(command);
     return resolveOutput({
         ...command.optsWithGlobals(),
+        ...detailOf(command.optsWithGlobals()),
+        compact: compactOf(command),
         ...(agent ? { capture: agent.result } : {}),
         ...(streams ? { streams } : {}),
         ...(env ? { env } : {}),
         ...(tty === undefined ? {} : { tty }),
     });
 };
-const detailOf = ({ brief, full }) => {
-    if (brief && full)
-        throw new CliError("validation_error", "--brief and --full ask for opposite things — pick one");
-    return brief ? { hitDetail: "brief" } : full ? { hitDetail: "full" } : {};
-};
 /** Everything a command needs that no messenger decides, resolved once. */
 export const baseContext = (command, resolveSettings) => {
     const environment = environmentOf(command);
@@ -66,9 +73,10 @@ export const baseContext = (command, resolveSettings) => {
     const flags = command.optsWithGlobals();
     const overrides = environment.agent?.overrides ?? [];
     const settings = resolveSettings(overrides.length > 0 ? { ...flags, permission: [...overrides, ...(flags.permission ?? [])] } : flags, { env });
-    const { renderer, format, color, streams } = resolveOutput({
+    const { renderer, format, color, streams, compact, full } = resolveOutput({
         ...settings,
         env,
+        compact: compactOf(command),
         ...detailOf(command.optsWithGlobals()),
         ...(command.optsWithGlobals().fields
             ? { fields: command.optsWithGlobals().fields }
@@ -85,6 +93,7 @@ export const baseContext = (command, resolveSettings) => {
         format,
         color,
         streams,
+        ...(compact ? { compact, full: full === true } : {}),
         env,
         ...(environment.keyring ? { keyring: environment.keyring } : {}),
         // The deadline inside the record, so a timeout finishes the run as failed rather than leaving it running.

package/dist/cli/envelope.d.ts

@@ -193,6 +193,10 @@ export interface AnswerOutput {
     renderer: Renderer;
     format: RenderFormat;
     streams: Streams;
+    /** One line per item from the same answer (WC-OUT-24); an agent's run keeps JSON. */
+    compact?: boolean;
+    /** With `compact`: each text whole, not cut. */
+    full?: boolean;
 }
 /** An answer as JSON-lines records, for a writer that streams objects: one per item, then the end record. */
 export declare const jsonlRecords: <T>(body: Body<T>) => object[];
@@ -201,7 +205,7 @@ export declare const jsonlRecords: <T>(body: Body<T>) => object[];
  * the items — `view` draws them — and each next step this CLI has, as a line on stderr. A partial answer the
  * command does not declare `partial` exits with its first issue's code, after printing what was read.
  */
-export declare const renderAnswer: <T>(command: Command, { renderer, format, streams }: AnswerOutput, body: Body<T>, view?: (body: Body<T>) => string) => void;
+export declare const renderAnswer: <T>(command: Command, { renderer, format, streams, compact, full }: AnswerOutput, body: Body<T>, view?: (body: Body<T>) => string) => void;
 /**
  * A document that is not an answer about the owner's data — the command registry, a `--dry-run` preview of what a
  * command would do — printed whole, with no envelope.

package/dist/cli/envelope.js

@@ -1,8 +1,9 @@
 import { exitCodeOfAnswer } from "@wirecat/cli-base";
 import { metaOf } from "@wirecat/cli-base/commands";
-import { itemEnvelopeSchema, jsonlOf, listEnvelopeSchema, MAX_NEXT_STEPS, } from "@wirecat/cli-base/standards";
+import { COMPACT_FLAG, itemEnvelopeSchema, jsonlOf, listEnvelopeSchema, MAX_NEXT_STEPS, } from "@wirecat/cli-base/standards";
 import * as v from "valibot";
 import { currentRun } from "../runs/scope.js";
+import { compactText, entityRows, rowShapeOf, rowsOfEntity, TEXT_CHARS } from "./compact.js";
 import { environmentOf, setExitCode } from "./context.js";
 import { withoutProviderRefs } from "./provider-refs.js";
 import { nextStep, rootOf, runnable, stepLine, withLines, withSafety } from "./steps.js";
@@ -128,6 +129,8 @@ export const sealed = (value) => {
     const { meta, ...rest } = withoutProviderRefs(value);
     return { ...rest, meta: metaNow(meta) };
 };
+/** The steps a compact answer prints, each rerunning in the compact form the caller chose. */
+const compactSteps = (root, steps) => steps.map((step) => step.kind === "command" ? { ...step, line: `${step.line ?? stepLine(root, step)} ${COMPACT_FLAG}` } : step);
 /** An answer as JSON lines: one line per item, then the end line. One thing is a list of one that has no more. */
 const linesOf = (body) => jsonlOf("items" in body ? body : { items: [body.item], page: { mode: "page", limit: 1, has_more: false }, meta: body.meta });
 /** An answer as JSON-lines records, for a writer that streams objects: one per item, then the end record. */
@@ -139,7 +142,7 @@ export const jsonlRecords = (body) => linesOf(sealed(body))
  * the items — `view` draws them — and each next step this CLI has, as a line on stderr. A partial answer the
  * command does not declare `partial` exits with its first issue's code, after printing what was read.
  */
-export const renderAnswer = (command, { renderer, format, streams }, body, view) => {
+export const renderAnswer = (command, { renderer, format, streams, compact, full }, body, view) => {
     if (!isBody(body))
         refuse(body);
     const root = rootOf(command);
@@ -149,7 +152,15 @@ export const renderAnswer = (command, { renderer, format, streams }, body, view)
     if (next.length === 0)
         delete kept.next;
     const whole = sealed(kept);
-    if (format === "json")
+    const environment = environmentOf(command);
+    const drawn = compact && !environment.agent;
+    if (drawn) {
+        const lined = whole.next ? { ...whole, next: compactSteps(root, whole.next) } : whole;
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        const { rows } = environment;
+        streams.data(compactText(lined, rowShapeOf(command, rows && entityRows(rows)), { timezone, textChars: full ? 0 : TEXT_CHARS }, rowsOfEntity(rows)));
+    }
+    else if (format === "json")
         renderer.result(whole);
     else if (format === "jsonl")
         for (const line of linesOf(whole).split("\n"))
@@ -161,7 +172,7 @@ export const renderAnswer = (command, { renderer, format, streams }, body, view)
     const code = exitCodeOfAnswer(whole.meta, metaOf(command).partial === true);
     if (code !== 0)
         setExitCode(command, code);
-    if (format === "json")
+    if (drawn || format === "json")
         return;
     for (const step of next)
         renderer.note(step.kind === "command" ? `→ ${step.why}: ${stepLine(root, step)}` : `→ ${step.why}`);

package/dist/cli/index.d.ts

@@ -1,5 +1,6 @@
 export { AI_ENTRIES, AI_SETTING_KEYS, type AISettings, resolveAISettings } from "../analysis/settings.js";
 export { parseDuration } from "../domain/duration.js";
+export { openOf, PROFILE_PLACEHOLDER, type ProfilesFor, type RefOpen, type RefSummary, refLabel, } from "../domain/ref-summaries.js";
 export { botTemplate } from "../entities/list-results.js";
 export { syncProgress } from "../entities/store-records.js";
 export { isCliFailure, isCommanderFailure } from "../errors/failures.js";
@@ -58,6 +59,7 @@ export type { CommandAvailability, DiscoveredCommand } from "./command-availabil
 export { commandContract, type JsonSchema, SCHEMA_DIALECT } from "./command-contract.js";
 export { type CommandRunOptions, type CommandRuns, commandRuns, type ProviderAnswer, type ProviderCall, providerEvent, providerRequest, type RunSettings, recordRuns, runSettings, type SavedRunSettings, } from "./command-runs.js";
 export { CONTRACT } from "./commands-command.js";
+export { type CompactOptions, compactText, entityRows, GENERIC_ROW, type RowColumn, type RowShape, type RowsResolver, type RowTable, type RowValue, rowShapeOf, rowsOfEntity, SHARED_ROWS, } from "./compact.js";
 export { refuseUnknownKey } from "./config-command.js";
 export { type ConfigIssue, type ConfigIssueKind, checkConfigText, issueMessage, readConfigFile, readConfigText, settingPathOf, withoutSetting, } from "./config-issues.js";
 export { loadSnakeCaseConfig } from "./config-keys.js";

package/dist/cli/index.js

@@ -1,5 +1,6 @@
 export { AI_ENTRIES, AI_SETTING_KEYS, resolveAISettings } from "../analysis/settings.js";
 export { parseDuration } from "../domain/duration.js";
+export { openOf, PROFILE_PLACEHOLDER, refLabel, } from "../domain/ref-summaries.js";
 export { botTemplate } from "../entities/list-results.js";
 export { syncProgress } from "../entities/store-records.js";
 export { isCliFailure, isCommanderFailure } from "../errors/failures.js";
@@ -50,6 +51,7 @@ export { PressLog, UpdatesCursor } from "./bot/updates.js";
 export { commandContract, SCHEMA_DIALECT } from "./command-contract.js";
 export { commandRuns, providerEvent, providerRequest, recordRuns, runSettings, } from "./command-runs.js";
 export { CONTRACT } from "./commands-command.js";
+export { compactText, entityRows, GENERIC_ROW, rowShapeOf, rowsOfEntity, SHARED_ROWS, } from "./compact.js";
 export { refuseUnknownKey } from "./config-command.js";
 export { checkConfigText, issueMessage, readConfigFile, readConfigText, settingPathOf, withoutSetting, } from "./config-issues.js";
 export { loadSnakeCaseConfig } from "./config-keys.js";

package/dist/cli/messenger/search-command.d.ts

@@ -1,5 +1,15 @@
 import { Command } from "commander";
+import type { SearchAllIncludingMeetingsFound } from "../../services/search-all-meetings.js";
 import { type Messenger } from "./context.js";
+import { type SourceSearched } from "./search-answers.js";
+export declare const searchAllOnlyOf: (value: string) => SourceSearched[];
+/** One `search all` hit as a person reads it. */
+export declare const searchAllLine: (item: SearchAllIncludingMeetingsFound["items"][number]) => string;
+/**
+ * `search all`'s scope, paging and matching options, the same in every CLI that mounts it (WC-ACCT-8): a messenger's
+ * and a calendar's.
+ */
+export declare const searchAllOptions: (command: Command) => Command;
 /**
  * `search <resource>`: every search of the tool, one leaf per resource (STANDARD.md, "Search
  * hierarchy"). `topics` only where the CLI has forum topics.

package/dist/cli/messenger/search-command.js

@@ -15,7 +15,7 @@ import { messagesSearchCommand } from "./messages-search-command.js";
 import { allAnswer, meaningNote, notesAnswer, offsetOf, SOURCE_SEARCHED, shownOf, } from "./search-answers.js";
 import { backendOptions, backendRequest, noteServer } from "./search-backend-options.js";
 import { topicsSearchCommand } from "./topics-command.js";
-const onlyOf = (value) => {
+export const searchAllOnlyOf = (value) => {
     const chosen = value.split(",").map((one) => one.trim());
     if (chosen.includes("mail"))
         throw new CliError("validation_error", "mail is searched by the separate memo CLI: install @wirecat/cli-memo, then `memo search mail …`");
@@ -24,7 +24,8 @@ const onlyOf = (value) => {
         throw new CliError("validation_error", `--only takes ${SOURCE_SEARCHED.join(", ")}, separated by commas; meetings when --source names a meeting account`);
     return [...new Set(chosen)];
 };
-const lineOf = (item) => item.kind === "meeting"
+/** One `search all` hit as a person reads it. */
+export const searchAllLine = (item) => item.kind === "meeting"
     ? `meeting · ${item.provider} · ${singleLine(item.title ?? "")}  ${item.ref}\n  ${item.timestamp ?? "time unknown"}  ${singleLine(item.text).slice(0, 200)}\n`
     : `${item.kind} · ${item.provider} · ${singleLine(item.title ?? "")}  ${item.ref}${item.url ? `\n  ${singleLine(item.url)}` : ""}\n  ${item.timestamp}${item.from?.name ? `  ${singleLine(item.from.name)}` : ""}  ${singleLine(item.text)}\n`;
 const maxMeetingsOf = (value) => {
@@ -34,6 +35,19 @@ const maxMeetingsOf = (value) => {
         throw new CliError("validation_error", "--max-meetings takes a whole number from 1, or all");
     return Number(value);
 };
+/**
+ * `search all`'s scope, paging and matching options, the same in every CLI that mounts it (WC-ACCT-8): a messenger's
+ * and a calendar's.
+ */
+export const searchAllOptions = (command) => command
+    .option("--only <resources>", "only these resources, separated by commas: messages, notes, events; meetings when --source names a meeting account", searchAllOnlyOf)
+    .option("--source <accounts>", "only these accounts, separated by commas: provider:account as a hit shows it, a provider, a kind or " +
+    "group:<name>; each resource reads the ones of its kind, and meetings only when it names one")
+    .option("--max-meetings <n>", "how many of the meeting account's meetings to look through, newest first, or all for every one (default 100)", maxMeetingsOf)
+    .option("--limit <n>", "how many", positiveCount("--limit"))
+    .option("--page <n>", "which page, starting at 1", positiveCount("--page"))
+    .option("--exact", "bare words and quotes match their exact form only, as exact:word does")
+    .option("--timezone <zone>", "the IANA timezone for calendar date boundaries");
 const allCommand = (messenger) => {
     const command = annotate(new Command("all"), { effects: REMOTE_READ, partial: true })
         .summary("search stored messages, notes, calendar events and selected meeting transcripts")
@@ -48,16 +62,8 @@ const allCommand = (messenger) => {
         .argument("<query...>", 'strict Lucene query: words, "phrases", AND/OR/NOT, field groups and date ranges')
         .addHelpText("after", SAVE_HELP)
         .addHelpText("after", `transcript: narrows a message search to voice transcripts, content: to the text of files, filename: to their names — \`${messenger.app.command} search all 'content:invoice'\`.
---json: the list is items; each result's reference is ref, with its kind.`)
-        .option("--only <resources>", "only these resources, separated by commas: messages, notes, events; meetings when --source names a meeting account", onlyOf)
-        .option("--source <accounts>", "only these accounts, separated by commas: provider:account as a hit shows it, a provider, a kind or " +
-        "group:<name>; each resource reads the ones of its kind, and meetings only when it names one")
-        .option("--max-meetings <n>", "how many of the meeting account's meetings to look through, newest first, or all for every one (default 100)", maxMeetingsOf)
-        .option("--limit <n>", "how many", positiveCount("--limit"))
-        .option("--page <n>", "which page, starting at 1", positiveCount("--page"))
-        .option("--exact", "bare words and quotes match their exact form only, as exact:word does")
-        .option("--timezone <zone>", "the IANA timezone for calendar date boundaries");
-    return backendOptions(annotate(command, { output: { entity: "hit" } }), messenger).action(async function (words) {
+--json: the list is items; each result's reference is ref, with its kind.`);
+    return backendOptions(annotate(searchAllOptions(command), { output: { entity: "hit" } }), messenger).action(async function (words) {
         const context = messengerContext(this, messenger);
         const { only, source, maxMeetings, limit: typed, page, exact, timezone, } = this.opts();
         const limit = typed ?? context.settings.limit;
@@ -99,7 +105,7 @@ const allCommand = (messenger) => {
                 context.renderer.note(found.server && !found.server.skipped
                     ? "nothing found in the local store or on the messenger's server"
                     : "nothing found in what the local store holds");
-            return found.items.map(lineOf).join("");
+            return found.items.map(searchAllLine).join("");
         });
     });
 };

package/dist/cli/messenger/store-maintenance-command.d.ts

@@ -3,9 +3,9 @@ import type { CacheDatabase } from "../../store/driver.js";
 import type { Messenger } from "./context.js";
 /** `doctor`'s short summary of the store. Must answer for a broken file, so an error is a field. */
 export declare const storeSummary: (env: NodeJS.ProcessEnv) => Promise<{
-    error?: undefined;
     path: string;
     exists: boolean;
+    error?: undefined;
 } | {
     path: string;
     exists: boolean;

package/dist/cli/program.d.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { type AppIdentity } from "../ports/app.js";
+import { type RowTable } from "./compact.js";
 import { type BaseEnvironment } from "./context.js";
 import { type FirstScreen } from "./help/first-screen.js";
 import type { CommandPermissions } from "./permission-keys.js";
@@ -16,6 +17,8 @@ export interface ProgramDefinition {
         resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "recordInput" | "keepSuccessfulRunsForDays" | "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "sources">>;
     };
     configure?: (program: Command) => void;
+    /** The app's own rows for `--compact`, by entity name; a shared entity's name is refused. */
+    rows?: RowTable;
     /** The tool's pitch and "what you can do" lines on `--help` and a bare run. */
     firstScreen?: FirstScreen;
     prepare?: (program: Command, environment: RunOptions) => void | Promise<void>;