@wirecat/cli-core 0.562.0 → 0.564.0

package/dist/services/reply-stats.d.ts

@@ -0,0 +1,48 @@
+import type { NewestMessage } from "../store/store.js";
+import type { ServiceDeps } from "./deps.js";
+export type ReplyWho = "me" | "others";
+export interface ReplyFigures {
+    replies: number;
+    medianMs: number | null;
+    p90Ms: number | null;
+    meanMs: number | null;
+}
+export interface ReplyTimes extends ReplyFigures {
+    who: ReplyWho;
+    by: "day" | "total";
+    buckets: {
+        under5m: number;
+        under1h: number;
+        under1d: number;
+        over1d: number;
+    };
+    rows: (ReplyFigures & {
+        key: string;
+    })[];
+}
+export interface Waiting {
+    chats: number;
+    messages: number;
+    oldestAt: string | null;
+    byKind: {
+        private: number;
+        group: number;
+    };
+}
+export interface ReplyQuery {
+    text?: string;
+    source?: string;
+    timezone?: string;
+}
+export interface ReplyStatsService {
+    responses(query: ReplyQuery & {
+        who: ReplyWho;
+        by: "day" | "total";
+    }): Promise<ReplyTimes>;
+    waiting(query: ReplyQuery): Promise<Waiting>;
+}
+/** Per waiting chat, how far back its unanswered messages are counted. */
+export declare const WAITING_TAIL = 100;
+/** Asks the owner something: a question in a one-to-one chat; in a group, a mention by id or `@handle`, or a reply. */
+export declare const waitsOnOwner: (newest: NewestMessage) => boolean;
+export declare const replyStatsService: (deps: ServiceDeps) => ReplyStatsService;

package/dist/services/reply-stats.js

@@ -0,0 +1,137 @@
+import { CliError } from "@wirecat/cli-base";
+import { parseLucene, timezoneOf } from "@wirecat/cli-base/query";
+import { delayStats } from "../domain/admin-statistics.js";
+import { calendarKey } from "../domain/calendar.js";
+import { rankingQuestion } from "../domain/rankings-options.js";
+import { MESSAGE_PARSING } from "../search/lucene/types.js";
+import { prepareLucene } from "./messages-search.js";
+const FIELDS = ["date", "chat", "kind"];
+/** Per waiting chat, how far back its unanswered messages are counted. */
+export const WAITING_TAIL = 100;
+/** Only AND-ed `date:`, `chat:` and `kind:` terms: each becomes an index bound, so no query reads every message. */
+const plainOnly = (text, command) => {
+    if (text === undefined)
+        return;
+    const refuse = () => {
+        throw new CliError("validation_error", `${command} reads date:, chat: and kind: terms, AND-ed — not words, other fields, OR or NOT`, { reason: "query.unsupported-field" });
+    };
+    const visit = (node) => {
+        if (node.kind === "boolean")
+            for (const clause of node.clauses) {
+                if (clause.occur !== "must")
+                    refuse();
+                visit(clause.node);
+            }
+        else if (!FIELDS.includes(node.field) || !["term", "phrase", "range"].includes(node.operator))
+            refuse();
+    };
+    visit(parseLucene(text, { ...MESSAGE_PARSING, defaultField: "text" }).root);
+};
+const scopeOf = (root, accounts) => {
+    const scope = { accounts, chats: [], kinds: [] };
+    const visit = (node) => {
+        if (node.kind === "boolean") {
+            for (const clause of node.clauses)
+                visit(clause.node);
+            return;
+        }
+        const { chat, date } = node.resolution ?? {};
+        if (chat)
+            scope.chats.push(chat);
+        else if (node.field === "kind")
+            scope.kinds.push(node.value.toLowerCase());
+        else if (date) {
+            if (date.lower !== undefined) {
+                const lower = date.lower + (date.lower_inclusive ? 0 : 1);
+                scope.since = Math.max(scope.since ?? lower, lower);
+            }
+            if (date.upper !== undefined) {
+                const upper = date.upper - (date.upper_inclusive ? 0 : 1);
+                scope.until = Math.min(scope.until ?? upper, upper);
+            }
+        }
+    };
+    visit(root);
+    return scope;
+};
+const figuresOf = (delays) => {
+    const { medianMilliseconds, p90Milliseconds } = delayStats(delays);
+    return {
+        replies: delays.length,
+        medianMs: medianMilliseconds,
+        p90Ms: p90Milliseconds,
+        meanMs: delays.length ? Math.round(delays.reduce((sum, one) => sum + one, 0) / delays.length) : null,
+    };
+};
+const MINUTE = 60_000;
+/** Asks the owner something: a question in a one-to-one chat; in a group, a mention by id or `@handle`, or a reply. */
+export const waitsOnOwner = (newest) => {
+    if (newest.mine)
+        return false;
+    if (newest.kind === "private")
+        return !newest.quiet && rankingQuestion(newest.text);
+    return (newest.addressed ||
+        (newest.ownerUsername !== null &&
+            new RegExp(`(^|[^\\w@])@${newest.ownerUsername.replace(/[^\w]/g, "\\$&")}(?!\\w)`, "i").test(newest.text)));
+};
+export const replyStatsService = (deps) => {
+    const prepared = async (query, command) => {
+        plainOnly(query.text, command);
+        const store = await deps.store();
+        const found = await prepareLucene(store, await deps.account(), {
+            ...(query.text === undefined ? {} : { text: query.text }),
+            ...(query.source === undefined ? {} : { source: query.source }),
+            timezone: timezoneOf(query.timezone),
+            limit: 1,
+        }, deps.messenger);
+        return { store, timezone: found.timezone, scope: scopeOf(found.execution.root, found.scopeAccounts) };
+    };
+    return {
+        responses: async ({ who, by, ...query }) => {
+            const { store, timezone, scope } = await prepared(query, "stats messages responses");
+            const delays = scope.accounts.length ? await store.queries.replyDelays(scope, who) : [];
+            const buckets = { under5m: 0, under1h: 0, under1d: 0, over1d: 0 };
+            for (const { delayMs } of delays) {
+                if (delayMs < 5 * MINUTE)
+                    buckets.under5m++;
+                else if (delayMs < 60 * MINUTE)
+                    buckets.under1h++;
+                else if (delayMs < 24 * 60 * MINUTE)
+                    buckets.under1d++;
+                else
+                    buckets.over1d++;
+            }
+            const days = new Map();
+            if (by === "day") {
+                const keyOf = calendarKey(timezone, "day");
+                for (const { repliedAt, delayMs } of delays) {
+                    const key = keyOf(repliedAt);
+                    const list = days.get(key) ?? [];
+                    list.push(delayMs);
+                    days.set(key, list);
+                }
+            }
+            return {
+                who,
+                by,
+                ...figuresOf(delays.map(({ delayMs }) => delayMs)),
+                buckets,
+                rows: [...days].sort(([a], [b]) => a.localeCompare(b)).map(([key, list]) => ({ key, ...figuresOf(list) })),
+            };
+        },
+        waiting: async (query) => {
+            const { store, scope } = await prepared(query, "stats messages waiting");
+            const chats = scope.accounts.length ? await store.queries.waitingChats(scope, waitsOnOwner, WAITING_TAIL) : [];
+            const firsts = chats.flatMap(({ unanswered }) => unanswered.at(-1) ?? []);
+            return {
+                chats: chats.length,
+                messages: chats.reduce((sum, { unanswered }) => sum + unanswered.length, 0),
+                oldestAt: firsts.length ? new Date(firsts.reduce((low, one) => Math.min(low, one))).toISOString() : null,
+                byKind: {
+                    private: chats.filter(({ kind }) => kind === "private").length,
+                    group: chats.filter(({ kind }) => kind === "group").length,
+                },
+            };
+        },
+    };
+};

package/dist/services/search-all.d.ts

@@ -79,6 +79,11 @@ export interface SearchAllFound {
         by: "words" | "words and meaning";
         meaningSkipped?: MeaningSkipped;
     };
+    /** How the mail was searched, when it was; never by meaning with `exact`. */
+    mail?: {
+        by: "words" | "words and meaning";
+        meaningSkipped?: MeaningSkipped;
+    };
     /** The messenger's server step for messages, as `search messages` reports it. */
     server?: ServerSearched;
     /** What the store held of the chats the messages were searched in; absent when messages were not searched. */

package/dist/services/search-all.js

@@ -7,7 +7,7 @@ import { INTERNAL_NOTES, kindIn } from "../domain/providers.js";
 import { runEmbedders } from "../embeddings/embed.js";
 import { DEFAULT_TEXT_MODEL } from "../embeddings/models.js";
 import { MESSAGE_PARSING } from "../search/lucene/types.js";
-import { planQuestion } from "../search/question-plan.js";
+import { planQuestion, questionLookup } from "../search/question-plan.js";
 import { calendarAccounts, searchEvents } from "./events-search.js";
 import { excerpt } from "./excerpt.js";
 import { MAX_SEARCH_OFFSET, searchStore } from "./messages-archive-search.js";
@@ -52,11 +52,17 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
     let hasMore = false;
     let notes;
     let events;
-    let messagesBy;
+    const by = {};
     let server;
+    // Every word of a sentence is rarely in one record: a question finds what holds some of them, as `--discover` does.
+    const discover = !request.exact && questionLookup(request.text) !== undefined;
+    /** Each hit found by meaning, by its cosine: one model for every source, so these compare across them. */
+    const cosines = new Map();
     let coverage;
     const messagesOf = async (kind) => {
         const given = request.scope?.[kind];
+        // The server still gets the question as typed: a query that is not a sentence still finds what it holds.
+        const discovers = discover && (kind === "mail" || request.backend !== "server");
         const query = {
             text: request.text,
             kind,
@@ -71,6 +77,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                 : {}),
             limit: window,
             ...(request.exact ? { exact: true } : {}),
+            ...(discovers ? { discover: true } : {}),
             ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
             ...(request.signal === undefined ? {} : { signal: request.signal }),
         };
@@ -109,7 +116,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         };
         const byWords = found.items.map((hit) => itemOf(hit, ["words"]));
         // Server hits are only those the server returned; the local vectors would add others.
-        if (kind === "mail" || !meaning || request.exact || request.backend === "server")
+        if (!meaning || request.exact || (kind === "messages" && request.backend === "server"))
             return byWords;
         const filters = filtersBeside(request.text);
         const lane = filters === undefined
@@ -121,10 +128,10 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
             }
             : await meaning(request.text, read, embedders);
         if ("skipped" in lane) {
-            messagesBy = { by: "words", meaningSkipped: lane.skipped };
+            by[kind] = { by: "words", meaningSkipped: lane.skipped };
             return byWords;
         }
-        messagesBy = { by: "words and meaning", ...(lane.partly ? { meaningSkipped: lane.partly } : {}) };
+        by[kind] = { by: "words and meaning", ...(lane.partly ? { meaningSkipped: lane.partly } : {}) };
         const near = await nearEligible(store, account, query, messenger, lane.ranked, filters ? { text: filters } : {});
         // One list per resource, as notes give theirs, so messages get no second vote against mail.
         const fused = new Map();
@@ -132,9 +139,13 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
             fused.set(item.ref, { item, score: 1 / (RRF_K + rank + 1) });
         });
         near.forEach((hit, rank) => {
+            cosines.set(hit.locator, hit.cosine);
             const held = fused.get(hit.locator);
             if (held)
                 held.item.foundBy = ["words", "meaning"];
+            // As in notes: a question's any-word list already holds what meaning finds, and a second vote buries the rest.
+            if (held && discovers)
+                return;
             fused.set(hit.locator, {
                 item: held?.item ?? itemOf(hit, ["meaning"]),
                 score: (held?.score ?? 0) + 1 / (RRF_K + rank + 1),
@@ -155,6 +166,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         embedders,
                         ...(chosen === undefined ? {} : notesScopeOf(chosen)),
                         ...(request.exact ? { exact: true } : {}),
+                        ...(discover ? { discover: true } : {}),
                         ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
                         ...(request.env === undefined ? {} : { env: request.env }),
                     });
@@ -163,6 +175,9 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         by: found.by,
                         ...(found.meaning_skipped === undefined ? {} : { meaningSkipped: found.meaning_skipped }),
                     };
+                    for (const hit of found.hits)
+                        if (hit.meaning_score !== undefined)
+                            cosines.set(hit.ref, hit.meaning_score);
                     lists.push(found.hits.map((hit) => ({
                         kind: hit.kind ?? "note",
                         ref: hit.ref,
@@ -192,6 +207,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         ...(command === undefined ? {} : { command }),
                         ...(request.env === undefined ? {} : { env: request.env }),
                         ...(request.exact ? { exact: true } : {}),
+                        ...(discover ? { discover: true } : {}),
                         ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
                         ...(request.signal === undefined ? {} : { signal: request.signal }),
                     });
@@ -200,6 +216,9 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                         by: found.by,
                         ...(found.meaning_skipped === undefined ? {} : { meaningSkipped: found.meaning_skipped }),
                     };
+                    for (const hit of found.hits)
+                        if (hit.meaning_score !== undefined)
+                            cosines.set(hit.ref, hit.meaning_score);
                     lists.push(found.hits.map((hit) => ({
                         kind: "event",
                         ref: hit.ref,
@@ -227,14 +246,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
     finally {
         await embedders.close();
     }
-    const ranked = new Map();
-    for (const list of lists)
-        list.forEach((item, rank) => {
-            const held = ranked.get(item.ref) ?? { item, score: 0 };
-            held.score += 1 / (RRF_K + rank + 1);
-            ranked.set(item.ref, held);
-        });
-    const ordered = [...ranked.values()].sort((a, b) => b.score - a.score).map(({ item }) => item);
+    const ordered = oneList(lists, cosines);
     const more = hasMore || ordered.length > window;
     return {
         query: request.text,
@@ -246,8 +258,29 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         skipped,
         ...(notes === undefined ? {} : { notes }),
         ...(events === undefined ? {} : { events }),
-        ...(messagesBy === undefined ? {} : { messages: messagesBy }),
+        ...(by.messages === undefined ? {} : { messages: by.messages }),
+        ...(by.mail === undefined ? {} : { mail: by.mail }),
         ...(server === undefined ? {} : { server }),
         ...(coverage === undefined ? {} : { coverage }),
     };
 };
+/**
+ * Every source's hits as one list: by the rank each has in its own source, then by cosine. Rank alone gave every
+ * source's hit at one rank the same score, so the sources took turns and the order among them was the order they were
+ * read in (MEMO-37). One model scores every source, so cosine compares across them; a hit meaning did not find comes
+ * after those it did at the same rank. Each source's own order is kept, so recall at any depth past the number of
+ * sources does not change.
+ */
+const oneList = (lists, cosines) => {
+    const place = new Map();
+    for (const list of lists)
+        list.forEach((item, rank) => {
+            const held = place.get(item.ref);
+            if (!held || rank < held.rank)
+                place.set(item.ref, { item, rank });
+        });
+    const cosine = (ref) => cosines.get(ref) ?? Number.NEGATIVE_INFINITY;
+    return [...place.values()]
+        .sort((a, b) => a.rank - b.rank || cosine(b.item.ref) - cosine(a.item.ref))
+        .map(({ item }) => item);
+};

package/dist/services/task-stats.d.ts

@@ -0,0 +1,41 @@
+import { type QueryAst } from "@wirecat/cli-base/query";
+import type { AccountKey, MessageStore } from "../store/store.js";
+import { type ColumnMap } from "../store/store.js";
+import { type TaskKind } from "../tasks/index.js";
+export declare const TASK_STATS_BY: readonly ["chat", "meeting", "project"];
+export type TaskStatsBy = (typeof TASK_STATS_BY)[number];
+/** The query field that sets the period; `closed` counts read the same range on the close time. */
+export declare const PERIOD_FIELD = "created";
+export interface TaskStatsRequest {
+    by?: TaskStatsBy;
+    query?: QueryAst;
+    timezone?: string;
+    /** A stored chat id: only that chat's tasks. */
+    group?: string;
+    kind?: TaskKind;
+}
+export interface TaskStatsGroup {
+    /** The stored chat id, `meeting:<account>/<meeting>`, or the project's store id. */
+    group: string;
+    name: string | null;
+    open: number;
+    created: number;
+    closed: number;
+    oldestOpenAt?: Date;
+    medianCloseMs?: number;
+    meanOpenAgeMs?: number;
+}
+export interface TaskStats {
+    by: TaskStatsBy;
+    open: number;
+    created: number;
+    closed: number;
+    medianCloseMs?: number;
+    meanOpenAgeMs?: number;
+    rows: TaskStatsGroup[];
+}
+/**
+ * `stats tasks show`: `open` is open now, `created` the tasks opened in the period, `closed` those closed in it; the
+ * other terms of the query narrow all three. `columns` reads the task query's fields on the row `t`.
+ */
+export declare const taskStatsOf: (store: MessageStore, account: AccountKey, { by, query, timezone, group, kind }: TaskStatsRequest, columns: ColumnMap, now?: number) => Promise<TaskStats>;

package/dist/services/task-stats.js

@@ -0,0 +1,126 @@
+import { CliError } from "@wirecat/cli-base";
+import { walkQuery } from "@wirecat/cli-base/query";
+import { parseMeetingReference } from "../meetings/index.js";
+import { withoutField } from "../store/index.js";
+import { queryFilter } from "../store/store.js";
+import { isClosedState } from "../tasks/index.js";
+import { taskAccount } from "./task-rules.js";
+export const TASK_STATS_BY = ["chat", "meeting", "project"];
+/** The query field that sets the period; `closed` counts read the same range on the close time. */
+export const PERIOD_FIELD = "created";
+/** Only as a required term at the top: inside OR or NOT it would no longer say which tasks the period covers. */
+const refuseNestedPeriod = (node, top = true) => {
+    if (node.kind === "predicate")
+        return;
+    const optional = node.clauses.some(({ occur }) => occur === "should");
+    for (const { occur, node: inner } of node.clauses) {
+        if (!walkQuery(inner).some(({ field }) => field === PERIOD_FIELD))
+            continue;
+        if (!top || optional || occur !== "must")
+            throw new CliError("validation_error", `${PERIOD_FIELD}: sets the period of stats tasks show: give it as a required term, not inside OR or NOT`);
+        refuseNestedPeriod(inner, top);
+    }
+};
+const renamed = (node, from, to) => node.kind === "predicate"
+    ? node.field === from
+        ? { ...node, field: to }
+        : node
+    : { ...node, clauses: node.clauses.map((clause) => ({ ...clause, node: renamed(clause.node, from, to) })) };
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+    const upper = sorted[middle] ?? 0;
+    return sorted.length % 2 === 1 ? upper : ((sorted[middle - 1] ?? 0) + upper) / 2;
+};
+const mean = (values) => Math.round(values.reduce((sum, one) => sum + one, 0) / values.length);
+const spread = (open, closeMs, now) => ({
+    ...(closeMs.length > 0 ? { medianCloseMs: median(closeMs) } : {}),
+    ...(open.length > 0 ? { meanOpenAgeMs: mean(open.map(({ createdAt }) => now - createdAt)) } : {}),
+});
+const and = (parts) => parts.length === 0
+    ? undefined
+    : { sql: parts.map(({ sql }) => `(${sql})`).join(" AND "), params: parts.flatMap(({ params }) => params) };
+/**
+ * `stats tasks show`: `open` is open now, `created` the tasks opened in the period, `closed` those closed in it; the
+ * other terms of the query narrow all three. `columns` reads the task query's fields on the row `t`.
+ */
+export const taskStatsOf = async (store, account, { by = "chat", query, timezone, group, kind }, columns, now = Date.now()) => {
+    if (query)
+        refuseNestedPeriod(query.root);
+    const time = (sql) => ({ type: "time", sql });
+    const read = { ...columns, [PERIOD_FIELD]: time("t.created_at"), closed: time("t.closed_at") };
+    const fixed = [
+        ...(group === undefined ? [] : [{ sql: "t.source_group = ?", params: [group] }]),
+        ...(kind === undefined ? [] : [{ sql: "t.type = ?", params: [kind] }]),
+        ...(by === "meeting" ? [{ sql: "t.source_kind = 'meeting'", params: [] }] : []),
+    ];
+    const options = { command: "stats tasks show", now, ...(timezone === undefined ? {} : { zone: timezone }) };
+    const where = (ast, more = []) => and([...fixed, ...more, ...(ast ? [queryFilter(ast, read, options)] : [])]);
+    const scope = by === "project" ? { board: true } : { account: taskAccount(account) };
+    const all = await store.tasks.statRows(scope, where(withoutField(query, PERIOD_FIELD)));
+    const created = await store.tasks.statRows(scope, where(query));
+    const closed = await store.tasks.statRows(scope, where(query && { ...query, root: renamed(query.root, PERIOD_FIELD, "closed") }, [
+        { sql: "t.closed_at IS NOT NULL", params: [] },
+    ]));
+    const keyOf = (row) => (by === "project" ? String(row.projectId) : (row.group ?? ""));
+    const groups = new Map();
+    const slot = (row) => {
+        const key = keyOf(row);
+        const found = groups.get(key) ?? { open: [], created: 0, closeMs: [] };
+        groups.set(key, found);
+        return found;
+    };
+    for (const row of all)
+        if (!isClosedState(row.state))
+            slot(row).open.push(row);
+    for (const row of created)
+        slot(row).created++;
+    for (const row of closed)
+        slot(row).closeMs.push((row.closedAt ?? row.createdAt) - row.createdAt);
+    const kept = [...groups].filter(([, one]) => one.open.length + one.created + one.closeMs.length > 0);
+    const ids = kept.map(([key]) => key);
+    const names = by === "chat"
+        ? await store.tasks.statNames("chat", ids, taskAccount(account))
+        : by === "project"
+            ? await store.tasks.statNames("project", ids)
+            : await meetingNames(store, ids);
+    const rows = kept.map(([key, one]) => ({
+        group: key,
+        name: names.get(key) ?? null,
+        open: one.open.length,
+        created: one.created,
+        closed: one.closeMs.length,
+        ...(one.open[0] ? { oldestOpenAt: new Date(one.open[0].createdAt) } : {}),
+        ...spread(one.open, one.closeMs, now),
+    }));
+    const open = kept.flatMap(([, one]) => one.open);
+    const closeMs = kept.flatMap(([, one]) => one.closeMs);
+    return {
+        by,
+        open: open.length,
+        created: created.length,
+        closed: closeMs.length,
+        ...spread(open, closeMs, now),
+        rows,
+    };
+};
+const meetingIdOf = (group) => {
+    try {
+        return String(parseMeetingReference(group).meetingId);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** A meeting task's group is `meeting:<account>/<meeting>`; its title is the meeting's, by the meeting's store id. */
+const meetingNames = async (store, groups) => {
+    const meetingOf = new Map(groups.flatMap((group) => {
+        const id = meetingIdOf(group);
+        return id === undefined ? [] : [[group, id]];
+    }));
+    const titles = await store.tasks.statNames("meeting", [...new Set(meetingOf.values())]);
+    return new Map([...meetingOf].flatMap(([group, id]) => {
+        const title = titles.get(id);
+        return title === undefined ? [] : [[group, title]];
+    }));
+};

package/dist/services/tasks.d.ts

@@ -3,9 +3,10 @@ import type * as v from "valibot";
 import { task as taskEntity } from "../entities/task.js";
 import { type CloseSuggestion, type SimilarTask, type TaskDraft, type TaskPair, type TaskPairSide, type TaskRelation } from "../store/index.js";
 import type { AccountKey, Author, MessageStore, TaskDetails, ThingLink } from "../store/store.js";
-import { type ClosedState, type GroupStats, TASK_KINDS, TASK_STATES, type Task, type TaskKind, type TaskOrigin } from "../tasks/index.js";
+import { type ClosedState, TASK_KINDS, TASK_STATES, type Task, type TaskKind, type TaskOrigin } from "../tasks/index.js";
 import type { ServiceDeps } from "./deps.js";
 import { type TaskCategory, type UnlistedCategory } from "./task-categories.js";
+import { type TaskStats, type TaskStatsRequest } from "./task-stats.js";
 export { TASK_KINDS, TASK_STATES };
 /** Source previews are read on demand; task records never retain source text. */
 export interface TaskView extends Task {
@@ -26,6 +27,18 @@ export declare const TASK_QUERY: {
     readonly backend: "sql";
     readonly fields: import("@wirecat/cli-base/query").FieldSpec[];
 };
+/** `stats tasks show`: the task query's fields, with the period as `created` in place of the two time fields. */
+export declare const TASK_STATS_QUERY: {
+    readonly entity: "task";
+    readonly backend: "sql";
+    readonly fields: readonly [...import("@wirecat/cli-base/query").FieldSpec[], {
+        readonly name: "created";
+        readonly type: "time";
+        readonly operators: readonly import("@wirecat/cli-base/query").Operator[];
+        readonly example: "created>=30d";
+        readonly relation: "the period: created counts the tasks opened in it, closed the tasks done or dismissed in it; open is open now";
+    }];
+};
 /** Which pairs `tasks duplicates list` lists: those waiting for the reviewing agent, or those it left to the owner. */
 export declare const PAIR_DECISIONS: readonly ["review", "unsure"];
 export type PairDecision = (typeof PAIR_DECISIONS)[number];
@@ -163,10 +176,10 @@ export interface TasksService {
     close(id: string, options: CloseRequest): Promise<ClosedTask>;
     /** The owner refuses an agent's close: the task stays open and the suggestion goes. */
     reject(id: string, by: TaskOrigin): Promise<TaskCard>;
-    stats(filter?: {
+    /** `chat` narrows to one chat, by name or id; see `taskStatsOf` for what each count means. */
+    stats(request?: Omit<TaskStatsRequest, "group"> & {
         chat?: string;
-        type?: TaskKind;
-    }): Promise<GroupStats[]>;
+    }): Promise<TaskStats>;
     /** Title, description, due date and next check; `null` clears one. */
     plan(id: string, plan: TaskPlan, by: TaskOrigin): Promise<TaskCard>;
     /**

package/dist/services/tasks.js

@@ -1,5 +1,5 @@
 import { CliError, isCliError, singleLine } from "@wirecat/cli-base";
-import { queryFieldsOf, walkQuery } from "@wirecat/cli-base/query";
+import { OPERATORS_BY_TYPE, queryFieldsOf, walkQuery } from "@wirecat/cli-base/query";
 import { isLocator, parseLocator } from "../domain/locator.js";
 import { formatReference } from "../domain/references.js";
 import { task as taskEntity } from "../entities/task.js";
@@ -9,6 +9,7 @@ import { createTaskService, isClosedState, TASK_KINDS, TASK_STATES, } from "../t
 import { storedChatId } from "./message-resolution.js";
 import { categorize, taskCategoryOf } from "./task-categories.js";
 import { taskAccount } from "./task-rules.js";
+import { PERIOD_FIELD, taskStatsOf } from "./task-stats.js";
 import { taskTagFilters } from "./task-tag-filters.js";
 export { TASK_KINDS, TASK_STATES };
 export const TASK_QUERY = {
@@ -41,6 +42,21 @@ export const TASK_QUERY = {
         },
     }),
 };
+/** `stats tasks show`: the task query's fields, with the period as `created` in place of the two time fields. */
+export const TASK_STATS_QUERY = {
+    entity: "task",
+    backend: "sql",
+    fields: [
+        ...TASK_QUERY.fields.filter(({ name }) => name !== "created_at" && name !== "closed_at"),
+        {
+            name: PERIOD_FIELD,
+            type: "time",
+            operators: OPERATORS_BY_TYPE.time,
+            example: `${PERIOD_FIELD}>=30d`,
+            relation: "the period: created counts the tasks opened in it, closed the tasks done or dismissed in it; open is open now",
+        },
+    ],
+};
 /** Which pairs `tasks duplicates list` lists: those waiting for the reviewing agent, or those it left to the owner. */
 export const PAIR_DECISIONS = ["review", "unsure"];
 export const TASK_PAIR_QUERY = {
@@ -143,6 +159,14 @@ export const tasksService = (deps, categories) => {
     const inStore = async (work) => work(await deps.store(), await deps.account());
     const service = (store) => createTaskService({ store: store.tasks });
     const groupOf = async (store, account, chat) => chat === undefined ? undefined : storedChatId(deps.messenger, chat, store, account, { includeLeft: true });
+    /** The task query's columns, with each `chat:` name in the query resolved to its stored chat id once. */
+    const queryColumns = async (store, account, query) => {
+        const groups = new Map();
+        for (const node of query ? walkQuery(query.root) : [])
+            if (node.field === "chat" && node.operator !== "wildcard" && !groups.has(node.value))
+                groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account, { includeLeft: true }));
+        return taskColumns(groups, await taskTagFilters(store, query));
+    };
     const refuseBare = (target) => {
         throw new CliError("validation_error", `no task ${singleLine(target)} — write task:${singleLine(target)} for a task`);
     };
@@ -204,12 +228,9 @@ export const tasksService = (deps, categories) => {
         : 0;
     return {
         list: ({ query, limit, offset, previews }) => inStore(async (store, account) => {
-            const groups = new Map();
-            for (const node of query ? walkQuery(query.root) : [])
-                if (node.field === "chat" && node.operator !== "wildcard" && !groups.has(node.value))
-                    groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account, { includeLeft: true }));
-            const tags = await taskTagFilters(store, query);
-            const where = query ? queryFilter(query, taskColumns(groups, tags), { command: "tasks list" }) : undefined;
+            const where = query
+                ? queryFilter(query, await queryColumns(store, account, query), { command: "tasks list" })
+                : undefined;
             const rows = await store.tasks.query(taskAccount(account), where, { limit: limit + 1, offset });
             const shown = rows.slice(0, limit);
             return {
@@ -484,13 +505,9 @@ export const tasksService = (deps, categories) => {
             await owned(store, account, subject);
             return store.tasks.similar({ task: subject }, options);
         }),
-        stats: (filter = {}) => inStore(async (store, account) => {
-            const group = await groupOf(store, account, filter.chat);
-            const rows = await service(store).stats({
-                account: taskAccount(account),
-                ...(filter.type === undefined ? {} : { kind: filter.type }),
-            });
-            return group === undefined ? rows : rows.filter((one) => one.group === group);
+        stats: ({ chat, ...request } = {}) => inStore(async (store, account) => {
+            const group = await groupOf(store, account, chat);
+            return taskStatsOf(store, account, { ...request, ...(group === undefined ? {} : { group }) }, await queryColumns(store, account, request.query));
         }),
     };
 };