@wirecat/cli-core 0.561.0 → 0.563.0

package/dist/store/sqlite/reply-times.js

@@ -0,0 +1,113 @@
+import { PEER_KIND } from "./lucene-fields.js";
+import { read } from "./transaction.js";
+const FAR = Number.MAX_SAFE_INTEGER;
+const chatsIn = (scope, kinds) => {
+    const params = [...scope.accounts.flatMap(({ provider, account }) => [provider, account]), ...kinds];
+    const parts = [
+        `(${scope.accounts.map(() => "(ac.provider=? AND ac.external_id=?)").join(" OR ") || "0"})`,
+        `${PEER_KIND} IN (${kinds.map(() => "?").join(",")})`,
+    ];
+    for (const { account, chatId } of scope.chats) {
+        parts.push("ac.provider=? AND ac.external_id=? AND c.external_id=?");
+        params.push(account.provider, account.account, chatId);
+    }
+    for (const kind of scope.kinds) {
+        parts.push(`${PEER_KIND}=?`);
+        params.push(kind);
+    }
+    // As in search: a chat named is read even when it is not searchable.
+    if (scope.chats.length === 0)
+        parts.push("c.searchable=1");
+    return { sql: parts.join(" AND "), params };
+};
+/**
+ * One row per reply in one-to-one chats. Each chat is read from the start of the run before the first message in the
+ * period, so a reply early in the period is timed from the first message it answers, however old.
+ */
+export const replyDelaysQuery = (scope, who) => {
+    const since = scope.since ?? -FAR;
+    const until = scope.until ?? FAR;
+    const chats = chatsIn(scope, ["private"]);
+    return {
+        sql: `WITH scoped AS MATERIALIZED (
+  SELECT c.id AS chat_id, coalesce((
+    SELECT p.sent_at FROM messages p WHERE p.chat_id=c.id AND p.sent_at<? AND p.deleted_at IS NULL
+      AND coalesce(p.outgoing,0)<>(SELECT coalesce(l.outgoing,0) FROM messages l
+        WHERE l.chat_id=c.id AND l.sent_at<? AND l.deleted_at IS NULL ORDER BY l.sent_at DESC LIMIT 1)
+    ORDER BY p.sent_at DESC LIMIT 1), ?) AS since
+  FROM chats c JOIN accounts ac ON ac.id=c.account_id WHERE ${chats.sql}
+), sides AS (
+  SELECT m.chat_id, m.id, m.sent_at, coalesce(m.outgoing,0) AS mine,
+    lag(coalesce(m.outgoing,0)) OVER (PARTITION BY m.chat_id ORDER BY m.sent_at, m.id) AS before
+  FROM scoped s JOIN messages m ON m.chat_id=s.chat_id AND m.sent_at>=s.since AND m.sent_at<=?
+  WHERE m.deleted_at IS NULL
+), runs AS (
+  SELECT sent_at, mine, lag(sent_at) OVER (PARTITION BY chat_id ORDER BY sent_at, id) AS asked_at
+  FROM sides WHERE before IS NULL OR before<>mine
+)
+SELECT sent_at AS replied_at, sent_at-asked_at AS delay_ms FROM runs
+WHERE asked_at IS NOT NULL AND mine=? AND sent_at>=? AND sent_at<=?`,
+        params: [since, since, -FAR, ...chats.params, until, who === "me" ? 1 : 0, since, until],
+    };
+};
+export const replyDelays = (context, scope, who) => {
+    const { sql, params } = replyDelaysQuery(scope, who);
+    return read(context.database, () => context.database
+        .prepare(sql)
+        .all(...params)
+        .map((row) => ({ repliedAt: Number(row.replied_at), delayMs: Number(row.delay_ms) })));
+};
+/** Each one-to-one chat's and group's newest message, found by index per chat, its time within the scope's bounds. */
+export const newestMessagesQuery = (scope, now) => {
+    const chats = chatsIn(scope, ["private", "group"]);
+    return {
+        sql: `SELECT c.id AS chat_id, ${PEER_KIND} AS kind, m.sent_at, coalesce(m.outgoing,0) AS mine, m.text,
+  (EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(m.mentions) THEN m.mentions ELSE '[]' END) WHERE value=ac.external_id)
+    OR coalesce(json_extract(CASE WHEN json_valid(m.reply_to) THEN m.reply_to ELSE '{}' END,'$.outgoing'),0)=1
+    OR EXISTS (SELECT 1 FROM messages q WHERE q.chat_id=c.id AND q.external_id=m.reply_to_external_id AND q.outgoing=1)
+  ) AS addressed,
+  (SELECT i.username FROM identities i WHERE i.provider=ac.provider AND i.external_id=ac.external_id) AS owner_username,
+  ((coalesce(c.muted,0)=1 AND (c.muted_until IS NULL OR c.muted_until>?)) OR coalesce(c.archived,0)=1)
+    AND coalesce(c.marked_unread,0)=0 AS quiet
+FROM chats c JOIN accounts ac ON ac.id=c.account_id
+JOIN messages m ON m.id=(SELECT n.id FROM messages n WHERE n.chat_id=c.id AND n.deleted_at IS NULL ORDER BY n.sent_at DESC LIMIT 1)
+WHERE ${chats.sql} AND m.sent_at>=? AND m.sent_at<=?`,
+        params: [now, ...chats.params, scope.since ?? -FAR, scope.until ?? FAR],
+    };
+};
+/** The newest `cap` messages of a chat, newest first: enough to find where the owner last spoke. */
+export const TAIL_SQL = "SELECT sent_at, coalesce(outgoing,0) AS mine FROM messages WHERE chat_id=? AND deleted_at IS NULL ORDER BY sent_at DESC LIMIT ?";
+/**
+ * The chats whose newest message `waits` accepts, with the other side's messages since the owner last spoke, read
+ * back no further than `cap` messages per chat.
+ */
+export const waitingChats = (context, scope, waits, cap) => {
+    const { sql, params } = newestMessagesQuery(scope, context.now());
+    const { database } = context;
+    return read(database, () => {
+        const tail = database.prepare(TAIL_SQL);
+        return database
+            .prepare(sql)
+            .all(...params)
+            .map((row) => ({
+            chatId: Number(row.chat_id),
+            kind: String(row.kind),
+            sentAt: Number(row.sent_at),
+            mine: Number(row.mine) === 1,
+            text: String(row.text),
+            addressed: Number(row.addressed) === 1,
+            ownerUsername: row.owner_username === null ? null : String(row.owner_username),
+            quiet: Number(row.quiet) === 1,
+        }))
+            .filter(waits)
+            .map(({ chatId, kind }) => {
+            const unanswered = [];
+            for (const row of tail.all(chatId, cap)) {
+                if (Number(row.mine) === 1)
+                    break;
+                unanswered.push(Number(row.sent_at));
+            }
+            return { kind, unanswered };
+        });
+    });
+};

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

@@ -33,7 +33,8 @@ export interface TaskFields {
     category?: string;
     /**
      * Another owner project, by key or `project:<id>`: the task takes the next key there; its old key still finds it.
-     * A subtask moves only with `parent: null` in the same edit.
+     * Its subtasks, all the way down, move with it and keep their parents. A subtask moves only with `parent: null` in
+     * the same edit.
      */
     project?: string;
     /** A project task's kind, bug, feature or chore. */
@@ -91,6 +92,15 @@ export interface TaskDetails {
     createdAt: string;
     updatedAt: string;
 }
+/** A subtask that moved to another project with its parent: its key before and after. */
+export interface MovedSubtask {
+    from: string;
+    to: string;
+}
+/** What `edit` answers: the task, and the subtasks a move to another project took with it. */
+export interface EditedTask extends TaskDetails {
+    movedSubtasks?: MovedSubtask[];
+}
 export interface RevisionCheck {
     /** The revision the caller read; a write on any other is refused (`task.stale`). */
     revision?: number;
@@ -167,7 +177,7 @@ export interface TaskEvent {
 /** Tasks beyond the package's four message kinds, and the fields the package does not know, on any task. */
 export interface WorkTasks extends TaskRelationsStore {
     create(input: NewWorkTask, by: Author): Promise<TaskDetails>;
-    edit(id: string, fields: TaskFields, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
+    edit(id: string, fields: TaskFields, by: Author, check?: RevisionCheck): Promise<EditedTask>;
     assign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
     unassign(id: string, assignment: TaskAssignment, by: Author, check?: RevisionCheck): Promise<TaskDetails>;
     /**

package/dist/store/sqlite/work-tasks.js

@@ -172,7 +172,7 @@ export const workTaskOperationsOver = (context) => {
     /** The task takes the target's next number and key; the source's counter never goes back, so its old key stays unique. */
     const moveToProject = (task, before, target, actor, at, detach) => {
         if (target === Number(before.project_id))
-            return;
+            return [];
         if (!onBoard(task))
             throw new CliError("validation_error", "only a project task moves to another project");
         const targetRow = database.prepare("SELECT key FROM projects WHERE id = ?").get(target);
@@ -182,25 +182,32 @@ export const workTaskOperationsOver = (context) => {
             const parent = taskIdOf(database, Number(before.parent_id));
             throw new CliError("validation_error", `${String(before.key)} is a subtask of ${parent}; detach it in the same write (parent none) to move it alone`, { reason: "task.is-subtask", parent });
         }
-        const children = database
-            .prepare("SELECT key FROM tasks WHERE parent_id = ? AND deleted_at IS NULL ORDER BY id")
-            .all(task)
-            .map((row) => String(row.key));
-        if (children.length)
-            throw new CliError("validation_error", `${String(before.key)} has subtasks (${children.join(", ")}); move or detach them first`, { reason: "task.has-subtasks", subtasks: children });
-        const counted = database
-            .prepare("UPDATE projects SET tasks_count = tasks_count + 1, updated_at = ? WHERE id = ? RETURNING key, tasks_count")
-            .get(at, target);
-        const number = Number(counted.tasks_count);
-        const key = `${String(counted.key)}-${number}`;
-        database
-            .prepare("UPDATE tasks SET project_id = ?, number = ?, key = ?, parent_id = NULL, updated_at = ? WHERE id = ?")
-            .run(target, number, key, at, task);
-        recordTaskEvent(database, task, actor, "project", {
-            project: [`project:${before.project_id}`, `project:${target}`],
-            key: [String(before.key), key],
-            ...(before.parent_id == null ? {} : { parent: [`task:${taskIdOf(database, Number(before.parent_id))}`, null] }),
-        }, at);
+        const renumber = (row, parent) => {
+            const counted = database
+                .prepare("UPDATE projects SET tasks_count = tasks_count + 1, updated_at = ? WHERE id = ? RETURNING key, tasks_count")
+                .get(at, target);
+            const number = Number(counted.tasks_count);
+            const key = `${String(counted.key)}-${number}`;
+            database
+                .prepare("UPDATE tasks SET project_id = ?, number = ?, key = ?, parent_id = ?, updated_at = ? WHERE id = ?")
+                .run(target, number, key, parent, at, Number(row.id));
+            recordTaskEvent(database, Number(row.id), actor, "project", {
+                project: [`project:${row.project_id}`, `project:${target}`],
+                key: [String(row.key), key],
+                ...(row.parent_id === parent ? {} : { parent: [`task:${taskIdOf(database, Number(row.parent_id))}`, null] }),
+            }, at);
+            return key;
+        };
+        renumber(before, null);
+        const moved = [];
+        const childrenOf = database.prepare("SELECT * FROM tasks WHERE parent_id = ? AND deleted_at IS NULL ORDER BY id");
+        for (const queue = [task]; queue.length > 0;) {
+            for (const child of childrenOf.all(queue.shift())) {
+                moved.push({ from: String(child.key), to: renumber(child, child.parent_id) });
+                queue.push(Number(child.id));
+            }
+        }
+        return moved;
     };
     const edit = (task, fields, actor, created = false) => {
         const before = rowById(task);
@@ -283,16 +290,18 @@ export const workTaskOperationsOver = (context) => {
             change("type", fields.type, "type");
             bump = true;
         }
-        if (fields.project !== undefined)
-            moveToProject(task, before, projectOf(fields.project), actor, at, fields.parent === null);
+        const moved = fields.project === undefined
+            ? []
+            : moveToProject(task, before, projectOf(fields.project), actor, at, fields.parent === null);
         if (set.length === 0) {
             if (bump)
                 database.prepare("UPDATE tasks SET revision = revision + 1 WHERE id = ?").run(task);
-            return;
+            return moved;
         }
         if (bump)
             set.push("revision = revision + 1");
         database.prepare(`UPDATE tasks SET ${set.join(", ")}, updated_at = ? WHERE id = ?`).run(...values, at, task);
+        return moved;
     };
     /** The column's tasks in board order, the moving one left out; no priority reads as 0, the bottom of low. */
     const columnOf = (task, status) => database
@@ -390,11 +399,11 @@ export const workTaskOperationsOver = (context) => {
         },
         edit: async (id, fields, by, check = {}) => {
             const task = required(id);
-            write(database, () => {
+            const moved = write(database, () => {
                 checkRevision(rowById(task), check.revision);
-                edit(task, fields, authorActor(context, by).actor);
+                return edit(task, fields, authorActor(context, by).actor);
             });
-            return details(task);
+            return moved.length > 0 ? { ...details(task), movedSubtasks: moved } : details(task);
         },
         /** `edit` inside the caller's write, so a decision that edits a task rolls back with it. */
         editNow: (id, fields, by) => {

package/dist/store/store.d.ts

@@ -123,6 +123,7 @@ export interface MessageStore {
 }
 export type { ChatHistoryShape, StoredHistorySkip } from "./sqlite/history-skips.js";
 export { BACKFILL_ON_OPEN, type StoreOptions } from "./sqlite/open-store.js";
+export type { ChatScope, NewestMessage, ReplyDelay, WaitingChat } from "./sqlite/reply-times.js";
 export { fileFacts, readStoreTables, type TableKind } from "./sqlite/store-tables.js";
 export declare const openStore: (options?: StoreOptions) => Promise<MessageStore>;
 export * from "./exports.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.561.0",
+  "version": "0.563.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

@@ -1127,6 +1127,11 @@
       "value": "<json>",
       "meaning": "the complete ranking component weights; replaces preset weights when --score is given"
     },
+    "--who": {
+      "value": "<side>",
+      "default": "me",
+      "meaning": "whose replies are timed: the owner's (me) or the other side's (others)"
+    },
     "--with-notes": {
       "meaning": "include your private notes, subject to contacts.notes.list permission"
     },
@@ -2766,6 +2771,9 @@
     "config": {
       "in": "all"
     },
+    "config migrate": {
+      "in": "all"
+    },
     "config repair": {
       "in": "all",
       "options": {
@@ -4528,6 +4536,15 @@
         "--selection": "all"
       }
     },
+    "stats messages responses": {
+      "in": "all",
+      "options": {
+        "--by": "all",
+        "--source": "all",
+        "--timezone": "all",
+        "--who": "all"
+      }
+    },
     "stats messages show": {
       "in": "all",
       "options": {
@@ -4606,6 +4623,13 @@
         "--timezone": "all"
       }
     },
+    "stats messages waiting": {
+      "in": "all",
+      "options": {
+        "--source": "all",
+        "--timezone": "all"
+      }
+    },
     "stats tasks": {
       "in": "all"
     },