@wirecat/cli-core 0.563.0 → 0.564.0

package/dist/store/sqlite/completeness.js

@@ -24,18 +24,54 @@ export const chatCompleteness = ({ database }, accountKey, chatIds) => {
        FROM chats c WHERE c.account_id = ? AND c.external_id IN (SELECT value FROM json_each(?))`)
         .all(accountKey, JSON.stringify(chatIds))
         .map((row) => {
-        const stretches = Number(row.stretches);
-        const reachesStart = Number(row.start) === 1;
-        const upToDate = row.newest === null ? null : row.held !== null && Number(row.held) >= Number(row.newest);
-        const gaps = stretches > 1;
-        const fetched = stretches > 0 || reachesStart;
-        return {
-            chatId: String(row.chat),
-            state: !fetched ? "unknown" : upToDate !== false && !gaps && reachesStart ? "complete" : "partial",
-            upToDate,
-            gaps,
-            reachesStart,
-            fetchedAt: toIso(row.fetched),
-        };
+        const facts = factsOf(row);
+        return { chatId: String(row.chat), ...facts, fetchedAt: toIso(row.fetched) };
     });
 };
+const factsOf = (row) => {
+    const stretches = Number(row.stretches);
+    const reachesStart = Number(row.start) === 1;
+    const upToDate = row.newest === null ? null : row.held !== null && Number(row.held) >= Number(row.newest);
+    const gaps = stretches > 1;
+    const fetched = stretches > 0 || reachesStart;
+    const state = !fetched
+        ? "unknown"
+        : upToDate !== false && !gaps && reachesStart
+            ? "complete"
+            : "partial";
+    return { state, upToDate, gaps, reachesStart };
+};
+export const COVERAGE_SQL = `SELECT c.last_message_at AS newest, c.message_count AS messages,
+     (SELECT m.sent_at FROM messages m WHERE m.chat_id = c.id AND m.deleted_at IS NULL
+       ORDER BY m.sent_at DESC LIMIT 1) AS held,
+     (SELECT m.sent_at FROM messages m WHERE m.chat_id = c.id AND m.deleted_at IS NULL
+       ORDER BY m.sent_at ASC LIMIT 1) AS oldest,
+     (SELECT count(*) FROM sync_ranges r WHERE r.chat_id = c.id) AS stretches,
+     EXISTS (SELECT 1 FROM sync_cursors s WHERE s.account_id = c.account_id AND s.key = 'history_start:' || c.external_id
+       AND NOT EXISTS (SELECT 1 FROM sync_ranges r WHERE r.chat_id = c.id AND r.from_key < CAST(s.value AS INTEGER)))
+       AS start,
+     EXISTS (SELECT 1 FROM sync_cursors s WHERE s.account_id = c.account_id
+       AND s.key IN ('history_start:' || c.external_id, 'fetched:' || c.external_id)) AS recorded
+   FROM chats c WHERE c.account_id = ? AND c.searchable = 1`;
+/**
+ * `chatCompleteness` over every searchable chat of the account in one statement. A chat whose history was pushed
+ * into the store (WhatsApp) has messages and no fetch record, so it counts as partial, not never. The newest and
+ * oldest held are read with ORDER BY … LIMIT 1, so each stops at the first live row of `messages_by_time` rather than
+ * relying on the planner's min/max shortcut, which the deleted_at filter may defeat.
+ */
+export const chatCoverage = ({ database }, accountKey) => {
+    const rows = database.prepare(COVERAGE_SQL).all(accountKey);
+    const coverage = { chats: rows.length, fetched: 0, partial: 0, never: 0, oldestMessageAt: null };
+    let oldest = null;
+    for (const row of rows) {
+        if (row.oldest !== null && (oldest === null || Number(row.oldest) < oldest))
+            oldest = Number(row.oldest);
+        if (factsOf(row).state === "complete")
+            coverage.fetched += 1;
+        else if (Number(row.stretches) === 0 && Number(row.recorded) === 0 && Number(row.messages) === 0)
+            coverage.never += 1;
+        else
+            coverage.partial += 1;
+    }
+    return { ...coverage, oldestMessageAt: toIso(oldest) };
+};

package/dist/store/sqlite/lucene-fields.js

@@ -349,6 +349,8 @@ export const PEER_KIND = "CASE WHEN json_extract(c.metadata,'$.peerKind') IN ('p
 const kind = messengerOnly(({ value }) => always(bound(`${PEER_KIND} = ?`, value.toLowerCase())));
 const has = ({ value }, { corpus, mail }) => {
     const wanted = value.toLowerCase();
+    if (wanted === "transcript")
+        return always(bound(mail ? "0" : "EXISTS (SELECT 1 FROM message_transcripts t WHERE t.message_id = m.id)"));
     return always(wanted === "text"
         ? bound("length(trim(coalesce(m.text,''))) > 0")
         : wanted === "link"

package/dist/store/sqlite/lucene-groups.d.ts

@@ -0,0 +1,15 @@
+/** `_direction`: the same groups, each split by `outgoing`, for counts of received and sent mail. */
+export type QueryGrouping = "chat" | "sender" | "time" | "sender_direction" | "time_direction";
+export interface QueryGroup {
+    provider?: string;
+    account?: string;
+    id: string | null;
+    name: string | null;
+    outgoing?: boolean;
+    count: number;
+}
+/** How `countQuery` groups the matches: the GROUP BY key and the columns each group reads. */
+export declare const GROUPS: Record<QueryGrouping, {
+    key: string;
+    select: string;
+}>;

package/dist/store/sqlite/lucene-groups.js

@@ -0,0 +1,21 @@
+/** How `countQuery` groups the matches: the GROUP BY key and the columns each group reads. */
+export const GROUPS = {
+    chat: {
+        key: "m.chat_id",
+        select: "ac.provider AS provider, ac.external_id AS account, c.external_id AS id, c.title AS name",
+    },
+    sender: {
+        key: "coalesce(m.sender_identity_id, -m.account_id)",
+        select: "ac.provider AS provider, ac.external_id AS account, i.external_id AS id, i.name AS name, max(m.outgoing) AS outgoing",
+    },
+    // Quarter hours, so a calendar day or hour in any zone (+05:30, +05:45) is a whole number of buckets.
+    time: { key: "m.sent_at / 900000", select: "CAST(min(m.sent_at / 900000) * 900000 AS TEXT) AS id, NULL AS name" },
+    sender_direction: {
+        key: "coalesce(m.sender_identity_id, -m.account_id), coalesce(m.outgoing, 0)",
+        select: "ac.provider AS provider, ac.external_id AS account, i.external_id AS id, i.name AS name, coalesce(m.outgoing, 0) AS outgoing",
+    },
+    time_direction: {
+        key: "m.sent_at / 900000, coalesce(m.outgoing, 0)",
+        select: "CAST(min(m.sent_at / 900000) * 900000 AS TEXT) AS id, NULL AS name, coalesce(m.outgoing, 0) AS outgoing",
+    },
+};

package/dist/store/sqlite/lucene.d.ts

@@ -1,18 +1,11 @@
 import type { Page } from "../../domain/models.js";
 import type { QueryExecution } from "../../search/lucene/resolved.js";
 import { type SqlValue } from "../driver.js";
+import { type QueryGroup, type QueryGrouping } from "./lucene-groups.js";
 import type { StoreContext } from "./open.js";
 import type { ScoredHit } from "./words.js";
 export { type Corpus, prefixOf } from "./lucene-fields.js";
-export type QueryGrouping = "chat" | "sender" | "time";
-export interface QueryGroup {
-    provider?: string;
-    account?: string;
-    id: string | null;
-    name: string | null;
-    outgoing?: boolean;
-    count: number;
-}
+export type { QueryGroup, QueryGrouping } from "./lucene-groups.js";
 export declare const matchQuery: (context: StoreContext, execution: QueryExecution) => Promise<Page<ScoredHit>>;
 /** Every match counted once, grouped; the work and candidate budgets of a search still apply. */
 export declare const countQuery: (context: StoreContext, execution: QueryExecution, by: QueryGrouping) => Promise<QueryGroup[]>;

package/dist/store/sqlite/lucene.js

@@ -6,6 +6,7 @@ import { TIME_LIMIT_FUNCTION, TimeLimitReached } from "../driver.js";
 import { emailHitsByPk } from "./emails.js";
 import { placeHits } from "./hit-places.js";
 import { combine, FIELD_COMPILERS, ftsMatch, SPEECH, } from "./lucene-fields.js";
+import { GROUPS } from "./lucene-groups.js";
 import { hitsByPk } from "./search.js";
 import { read } from "./transaction.js";
 import { transcriptItems, transcriptTerms } from "./transcript-query.js";
@@ -32,18 +33,6 @@ const MAIL = {
     item: "email",
     thread: "email_thread",
 };
-const GROUPS = {
-    chat: {
-        key: "m.chat_id",
-        select: "ac.provider AS provider, ac.external_id AS account, c.external_id AS id, c.title AS name",
-    },
-    sender: {
-        key: "coalesce(m.sender_identity_id, -m.account_id)",
-        select: "ac.provider AS provider, ac.external_id AS account, i.external_id AS id, i.name AS name, max(m.outgoing) AS outgoing",
-    },
-    // Quarter hours, so a calendar day or hour in any zone (+05:30, +05:45) is a whole number of buckets.
-    time: { key: "m.sent_at / 900000", select: "CAST(min(m.sent_at / 900000) * 900000 AS TEXT) AS id, NULL AS name" },
-};
 export const matchQuery = (context, execution) => runQuery(context, execution);
 /** Every match counted once, grouped; the work and candidate budgets of a search still apply. */
 export const countQuery = (context, execution, by) => runQuery(context, execution, by);

package/dist/store/sqlite/meeting-stats.d.ts

@@ -1,5 +1,7 @@
 import { type MeetingStatsStore } from "../../meetings/index.js";
 import type { StoreContext } from "./open.js";
+/** One row per selected meeting through `meetings_by_time`; a current transcript is neither deleted nor superseded. */
+export declare const meetingCountsSql: (where: string) => string;
 /**
  * One transcript per meeting — its earliest current one — so a local transcript beside the provider's does not count
  * the talk twice. Words are counted from spaces in SQL, so no transcript text leaves the database.

package/dist/store/sqlite/meeting-stats.js

@@ -1,10 +1,17 @@
 import { CliError } from "@wirecat/cli-base";
-import { aggregateMeetingStats } from "../../meetings/index.js";
+import { aggregateMeetingCounts, aggregateMeetingStats, } from "../../meetings/index.js";
 import { checkMeetingCancelled } from "./meeting-operation.js";
 import { positiveReadInteger } from "./meeting-reads.js";
 import { meetingSelectionSql } from "./meeting-selection.js";
 import { read } from "./transaction.js";
 const MOST_ROWS = 500_000;
+/** One row per selected meeting through `meetings_by_time`; a current transcript is neither deleted nor superseded. */
+export const meetingCountsSql = (where) => `SELECT m.started_at, coalesce(m.duration_ms, m.ended_at - m.started_at) AS duration_ms,
+     EXISTS (SELECT 1 FROM meeting_transcripts t WHERE t.meeting_id = m.id AND t.deleted_at IS NULL
+       AND t.superseded_at IS NULL) AS transcribed,
+     s.external_id AS series_key, CASE WHEN s.id IS NULL THEN NULL ELSE coalesce(s.title, m.title) END AS series_title
+   FROM meetings m LEFT JOIN meeting_series s ON s.id = m.meeting_series_id
+   WHERE ${where} ORDER BY m.started_at DESC`;
 /**
  * One transcript per meeting — its earliest current one — so a local transcript beside the provider's does not count
  * the talk twice. Words are counted from spaces in SQL, so no transcript text leaves the database.
@@ -52,4 +59,23 @@ export const meetingStatsOver = ({ database }) => ({
             })), input.timeZone);
         });
     },
+    async meetingCounts(input) {
+        checkMeetingCancelled(input.signal);
+        positiveReadInteger(input.accountId, "accountId");
+        return read(database, () => {
+            const { clauses, params } = meetingSelectionSql(input);
+            const meetings = database
+                .prepare(meetingCountsSql(clauses.join(" AND ")))
+                .all(...params)
+                .map((row) => ({
+                startedAt: row.started_at === null ? null : Number(row.started_at),
+                durationMs: row.duration_ms === null ? null : Number(row.duration_ms),
+                transcribed: Number(row.transcribed) === 1,
+                seriesKey: row.series_key === null ? null : String(row.series_key),
+                seriesTitle: row.series_title === null ? null : String(row.series_title),
+            }));
+            checkMeetingCancelled(input.signal);
+            return aggregateMeetingCounts(meetings, input.by, input.timeZone, input.limit);
+        });
+    },
 });

package/dist/store/sqlite/retention.js

@@ -1,14 +1,9 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
-import { calendarKey } from "../../domain/calendar.js";
+import { calendarKey, weekKey } from "../../domain/calendar.js";
 import { RETENTION_TOLERANCE, retentionCohorts, validateRetentionOptions, } from "../../domain/retention.js";
 import { chatCompleteness } from "./completeness.js";
 const iso = (at) => new Date(at).toISOString();
-const week = (day) => {
-    const date = new Date(`${day}T00:00:00Z`);
-    date.setUTCDate(date.getUTCDate() - ((date.getUTCDay() + 6) % 7));
-    return date.toISOString().slice(0, 10);
-};
 export const retentionQuery = (context, accountPk, chatPk, chatId, options, evidence) => {
     validateRetentionOptions(options);
     if (options.cutoff > context.now())
@@ -33,7 +28,7 @@ export const retentionQuery = (context, accountPk, chatPk, chatId, options, evid
     const activityStatement = database.prepare(`SELECT min(sent_at) AS at FROM messages WHERE chat_id=? AND sender_identity_id=? AND deleted_at IS NULL AND sent_at >= ? AND sent_at < ?`);
     const stays = raw.map((row) => {
         const joinedAt = Number(row.joined_at), pk = Number(row.pk), end = joinedAt + options.within;
-        const day = dayOf(joinedAt), cohort = options.by === "week" ? week(day) : day;
+        const day = dayOf(joinedAt), cohort = options.by === "week" ? weekKey(day) : day;
         const absence = departureStatement.get(chatPk, Math.max(joinedAt, Number(row.first_seen_at)), options.cutoff, pk);
         const upper = absence ? Number(absence.observed_at) : null;
         const positive = lastPositiveStatement.get(pk, upper ?? options.cutoff + 1);

package/dist/store/sqlite/task-board.js

@@ -37,6 +37,7 @@ export const PROJECT_TASK_FIELDS = [
         relation: "the due date as a board groups it: overdue (open work due before today), today, upcoming (the next 7 days " +
             "after today), later, or none",
     }),
+    field("created", "time", "created:>=30d", { relation: "when it was opened" }),
     field("closed", "time", "closed:>=14d", { relation: "when it was done or dismissed" }),
     field("ready", "bool", "ready:true", { relation: "open work whose blocked-by tasks are all done" }),
     field("text", "txt", "text:invoice", { relation: "words of the title and description; a bare word means this" }),
@@ -183,6 +184,7 @@ export const projectTaskColumns = (now, zone) => ({
     agent: { where: agentWhere },
     parent: { where: parentWhere },
     due: { type: "time", sql: "t.due_at" },
+    created: { type: "time", sql: "t.created_at" },
     closed: { type: "time", sql: "t.closed_at" },
     overdue: { where: (node) => truth(node, dueGroups(now, zone).overdue) },
     when: {

package/dist/store/sqlite/task-stats.d.ts

@@ -0,0 +1,32 @@
+import type { StoreContext } from "./open.js";
+import type { Where } from "./query-filter.js";
+/** One account's tasks (its inbox), or the owner's project tasks across every project. */
+export type TaskStatScope = {
+    account: string;
+} | {
+    board: true;
+};
+export interface TaskStatRow {
+    group: string | null;
+    sourceKind: string | null;
+    projectId: number;
+    state: string;
+    createdAt: number;
+    closedAt: number | null;
+}
+export type TaskStatNames = "chat" | "meeting" | "project";
+export interface TaskStats {
+    /** One narrow row per live task in the scope that `where` keeps, oldest first. */
+    statRows(scope: TaskStatScope, where: Where | undefined): Promise<TaskStatRow[]>;
+    /** Titles by id, read once: chats by external id within `account`, meetings and projects by their store id. */
+    statNames(kind: TaskStatNames, ids: readonly string[], account?: string): Promise<Map<string, string>>;
+}
+/** Every statement `stats tasks show` runs, for the query-plan test. */
+export declare const TASK_STATS_SQL: {
+    readonly rows: (board: boolean, filter: string) => string;
+    readonly chat: string;
+    readonly meeting: "SELECT CAST(id AS TEXT) AS id, title AS name FROM meetings WHERE id IN (SELECT value FROM json_each(?))";
+    readonly project: "SELECT CAST(id AS TEXT) AS id, name FROM projects WHERE id IN (SELECT value FROM json_each(?))";
+};
+/** `inbox` finds an account's inbox project without making one. */
+export declare const taskStatsOver: ({ database }: StoreContext, inbox: (account: string) => number | undefined) => TaskStats;

package/dist/store/sqlite/task-stats.js

@@ -0,0 +1,45 @@
+import { BOARD_SCOPE } from "./task-board.js";
+const ACCOUNT_SCOPE = "t.package_id IS NOT NULL AND t.deleted_at IS NULL AND t.project_id = ?";
+/** Every statement `stats tasks show` runs, for the query-plan test. */
+export const TASK_STATS_SQL = {
+    rows: (board, filter) => "SELECT t.source_group, t.source_kind, t.project_id, t.status, t.created_at, t.closed_at FROM tasks t " +
+        `WHERE ${board ? BOARD_SCOPE : ACCOUNT_SCOPE}${filter} ORDER BY t.created_at, t.id`,
+    chat: "SELECT c.external_id AS id, c.title AS name FROM chats c JOIN accounts a ON a.id = c.account_id " +
+        "WHERE a.provider = ? AND a.external_id = ? AND c.external_id IN (SELECT value FROM json_each(?))",
+    meeting: "SELECT CAST(id AS TEXT) AS id, title AS name FROM meetings WHERE id IN (SELECT value FROM json_each(?))",
+    project: "SELECT CAST(id AS TEXT) AS id, name FROM projects WHERE id IN (SELECT value FROM json_each(?))",
+};
+/** `inbox` finds an account's inbox project without making one. */
+export const taskStatsOver = ({ database }, inbox) => ({
+    statRows: async (scope, where) => {
+        const filter = where === undefined ? "" : ` AND (${where.sql})`;
+        const board = !("account" in scope);
+        const project = board ? undefined : inbox(scope.account);
+        if (!board && project === undefined)
+            return [];
+        return database
+            .prepare(TASK_STATS_SQL.rows(board, filter))
+            .all(...(project === undefined ? [] : [project]), ...(where?.params ?? []))
+            .map((row) => ({
+            group: row.source_group == null ? null : String(row.source_group),
+            sourceKind: row.source_kind == null ? null : String(row.source_kind),
+            projectId: Number(row.project_id),
+            state: String(row.status),
+            createdAt: Number(row.created_at),
+            closedAt: row.closed_at == null ? null : Number(row.closed_at),
+        }));
+    },
+    statNames: async (kind, ids, account) => {
+        if (ids.length === 0)
+            return new Map();
+        let params = [JSON.stringify(ids.map(Number))];
+        if (kind === "chat") {
+            if (account === undefined)
+                return new Map();
+            const at = account.indexOf(":");
+            params = [account.slice(0, at), account.slice(at + 1), JSON.stringify(ids)];
+        }
+        const rows = database.prepare(TASK_STATS_SQL[kind]).all(...params);
+        return new Map(rows.filter((row) => row.name != null).map((row) => [String(row.id), String(row.name)]));
+    },
+});

package/dist/store/sqlite/tasks.d.ts

@@ -6,11 +6,12 @@ import { type TaskSimilarity } from "./task-candidates.js";
 import { type CloseSuggestion } from "./task-close.js";
 import { type TaskCloseStore } from "./task-close-store.js";
 import { type TaskPairs } from "./task-pairs.js";
+import { type TaskStats } from "./task-stats.js";
 import { type WorkTasks } from "./work-tasks.js";
 export { inboxKey, linkInbox, taskAccountOf } from "./task-keys.js";
 export { taskIdOf, taskRowOf } from "./things.js";
 /** `TaskStore` for `src/tasks/`, plus a way from its task ids to the store's rows. */
-export interface StoreTaskStore extends Omit<Required<TaskStore>, "reviewDuplicates">, WorkTasks, TaskSimilarity, TaskPairs, TaskCloseStore {
+export interface StoreTaskStore extends Omit<Required<TaskStore>, "reviewDuplicates">, WorkTasks, TaskSimilarity, TaskPairs, TaskStats, TaskCloseStore {
     /** The default list (or one an older build saved here) with the shared config file's `task_categories` edits. */
     categories(): Promise<readonly TaskCategory[]>;
     /** The shared config file whose `task_categories` edits the list. */

package/dist/store/sqlite/tasks.js

@@ -11,6 +11,7 @@ import { CLEAR_SUGGESTION, closeSuggestionOf, SUGGESTION_COLUMNS } from "./task-
 import { taskCloseOver } from "./task-close-store.js";
 import { inboxKey, typedKey } from "./task-keys.js";
 import { taskPairsOver } from "./task-pairs.js";
+import { taskStatsOver } from "./task-stats.js";
 import { taskRowOf, thingOf } from "./things.js";
 import { read, write } from "./transaction.js";
 import { recordTaskEvent, workTasksOver } from "./work-tasks.js";
@@ -91,6 +92,7 @@ export const taskStoreOver = (context) => {
         ...workTasksOver(context),
         ...similarity,
         ...taskPairsOver(context, similarity),
+        ...taskStatsOver(context, (account) => inbox(account, false)),
         ...taskCloseOver(context),
         rowOf: (id) => taskRowOf(database, id),
         categories: async () => listOf(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.563.0",
+  "version": "0.564.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",

package/parity.json

@@ -160,7 +160,7 @@
     "--by": {
       "value": "<grouping>",
       "meaning": "what to count by",
-      "note": "each command names its own groupings — stats messages show chat, sender, day or hour, and searches create the same for stats messages show --saved; stats chats show day or week, as a series beside its totals — so it differs on purpose (Help text rule 4)"
+      "note": "each command names its own groupings — stats messages show chat, sender, day or hour, and searches create the same for stats messages show --saved; stats chats show day or week, as a series beside its totals; stats tasks show chat, meeting or project — so it differs on purpose (Help text rule 4)"
     },
     "--calls": {
       "value": "<who>",
@@ -4636,9 +4636,15 @@
     "stats tasks show": {
       "in": "all",
       "options": {
+        "--by": {
+          "in": "all"
+        },
         "--chat": {
           "in": "all"
         },
+        "--timezone": {
+          "in": "all"
+        },
         "--type": {
           "in": "all"
         }
@@ -4676,6 +4682,12 @@
         "--encrypt": "all"
       }
     },
+    "store chats": {
+      "in": "all"
+    },
+    "store chats status": {
+      "in": "all"
+    },
     "store check": {
       "in": "all"
     },