@wirecat/cli-core 0.511.0 → 0.512.0

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

@@ -1,11 +1,15 @@
 import { CliError } from "@wirecat/cli-base";
 import { TASK_TYPES, WORK_TASK_TYPES } from "../../domain/knowledge.js";
-import { TASK_STATES } from "../../tasks/index.js";
+import { isClosedState, TASK_STATES } from "../../tasks/index.js";
 import { folded } from "./folded.js";
 import { authorActor } from "./memories.js";
+import { CORPORA, drainCorpus } from "./note-index.js";
 import { requiredThing } from "./notes.js";
+import { queryFilter } from "./query-filter.js";
+import { stemmerCache } from "./stems.js";
+import { BOARD_SCOPE, boardOrder, projectTaskColumns, withoutField } from "./task-board.js";
 import { closeSuggestionOf, SUGGESTION_COLUMNS } from "./task-close.js";
-import { inboxKey } from "./task-keys.js";
+import { INBOX_KEY_LENGTH, inboxKey } from "./task-keys.js";
 import { taskRelationsStoreOver } from "./task-relations.js";
 import { taskIdOf, taskRowOf, thingOf } from "./things.js";
 import { write } from "./transaction.js";
@@ -120,6 +124,18 @@ export const workTaskOperationsOver = (context) => {
             updatedAt: iso(row.updated_at),
         };
     };
+    const stemmerFor = stemmerCache();
+    const boardWhere = (query, zone, at) => {
+        if (query === undefined)
+            return { sql: BOARD_SCOPE, params: [] };
+        const where = queryFilter(query, projectTaskColumns(at), {
+            command: "tasks list",
+            now: at,
+            ...(zone ? { zone } : {}),
+        });
+        return { sql: `${BOARD_SCOPE} AND (${where.sql})`, params: where.params };
+    };
+    const countOf = (where) => Number(database.prepare(`SELECT count(*) AS n FROM tasks t WHERE ${where.sql}`).get(...where.params)?.n ?? 0);
     const rowById = (id) => database.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
     const details = (id) => detailsOf(rowById(id));
     const edit = (task, fields, actor, created = false) => {
@@ -154,12 +170,21 @@ export const workTaskOperationsOver = (context) => {
         if (fields.status !== undefined) {
             if (!TASK_STATES.includes(fields.status))
                 throw new CliError("validation_error", `a task's status is one of ${TASK_STATES.join(", ")}`);
-            const closed = fields.status !== "open";
+            if ((fields.status === "todo" || fields.status === "in_progress") &&
+                String(database.prepare("SELECT key FROM projects WHERE id = ?").get(Number(before.project_id))?.key).length ===
+                    INBOX_KEY_LENGTH)
+                throw new CliError("validation_error", "a task from a message is open, done or dismissed; todo and in_progress are for a project task");
+            const closed = isClosedState(fields.status);
+            const reopened = !closed && isClosedState(String(before.status));
             if (before.status !== fields.status) {
                 change("status", fields.status, "status");
-                change("closed_at", closed ? at : null);
-                change("closed_by_type", closed ? actor.type : null);
-                change("closed_by_id", closed ? actor.id : null);
+                if (fields.status === "in_progress" && before.started_at == null)
+                    change("started_at", at);
+                if (closed || reopened) {
+                    change("closed_at", closed ? at : null);
+                    change("closed_by_type", closed ? actor.type : null);
+                    change("closed_by_id", closed ? actor.id : null);
+                }
                 if (closed) {
                     change("claimed_by", null);
                     change("claimed_until", null);
@@ -168,6 +193,11 @@ export const workTaskOperationsOver = (context) => {
                 }
                 else
                     change("close_certainty", null);
+                // Why it was closed no longer holds once it is open again.
+                if (reopened && fields.reason === undefined) {
+                    change("close_reason", null);
+                    change("close_reason_folded", null);
+                }
             }
         }
         if (fields.reason !== undefined) {
@@ -296,11 +326,11 @@ export const workTaskOperationsOver = (context) => {
             const at = now();
             const won = write(database, () => database
                 .prepare("UPDATE tasks SET claimed_by = ?, claimed_until = ?, updated_at = ? " +
-                "WHERE id = ? AND status = 'open' AND (claimed_by IS NULL OR claimed_until < ? OR claimed_by = ?) RETURNING id")
+                "WHERE id = ? AND status NOT IN ('done', 'dismissed') AND (claimed_by IS NULL OR claimed_until < ? OR claimed_by = ?) RETURNING id")
                 .get(holder, until.getTime(), at, task, at, holder));
             if (!won) {
                 const row = rowById(task);
-                if (row.status !== "open")
+                if (isClosedState(String(row.status)))
                     throw new CliError("validation_error", `task ${String(row.key)} is ${String(row.status)}; only an open task is claimed`);
                 throw new CliError("validation_error", `${String(row.claimed_by)} holds task ${String(row.key)} until ${iso(row.claimed_until)}; ` +
                     "wait for it, or ask them to release it", { reason: "task.claimed", holder: String(row.claimed_by), until: iso(row.claimed_until) });
@@ -322,12 +352,75 @@ export const workTaskOperationsOver = (context) => {
             });
             return details(task);
         },
+        board: async (query, { limit, offset = 0, sort = "priority", descending = false, zone }) => {
+            if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500)
+                throw new CliError("validation_error", "a page of tasks holds 1–500");
+            drainCorpus(database, CORPORA.task, stemmerFor);
+            const where = boardWhere(query, zone, now());
+            const rows = database
+                .prepare(`SELECT t.* FROM tasks t WHERE ${where.sql} ORDER BY ${boardOrder(sort, descending)} LIMIT ? OFFSET ?`)
+                .all(...where.params, limit, offset);
+            return { items: rows.map(detailsOf), total: countOf(where) };
+        },
+        boardCounts: async (query, { zone } = {}) => {
+            drainCorpus(database, CORPORA.task, stemmerFor);
+            const at = now();
+            const without = (name) => boardWhere(withoutField(query, name), zone, at);
+            const grouped = (name, select, from, group) => {
+                const where = without(name);
+                return database
+                    .prepare(`SELECT ${select}, count(*) AS n FROM tasks t ${from} WHERE ${where.sql} GROUP BY ${group}`)
+                    .all(...where.params);
+            };
+            const project = grouped("project", "p.key, p.name", "JOIN projects p ON p.id = t.project_id", "p.id")
+                .map((row) => ({ value: String(row.key), name: String(row.name), count: Number(row.n) }))
+                .sort((a, b) => a.value.localeCompare(b.value));
+            const assigned = grouped("assignee", "a.assignee_id AS person, pe.name", "LEFT JOIN task_assignments a ON a.task_id = t.id AND a.assignee_type = 'person' AND a.role = 'assignee' " +
+                "LEFT JOIN persons pe ON pe.id = a.assignee_id", "a.assignee_id");
+            const assignee = assigned
+                .map((row) => ({
+                value: row.person == null ? "none" : `person:${row.person}`,
+                name: row.name == null ? null : String(row.name),
+                count: Number(row.n),
+            }))
+                .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
+            const priorities = new Map(grouped("priority", "t.priority", "", "t.priority").map((row) => [row.priority, Number(row.n)]));
+            const states = new Map(grouped("state", "t.status", "", "t.status").map((row) => [row.status, Number(row.n)]));
+            return {
+                total: countOf(boardWhere(query, zone, at)),
+                project,
+                assignee,
+                priority: [0, 1, 2, 3, 4, null].map((value) => ({ value, count: priorities.get(value) ?? 0 })),
+                state: TASK_STATES.map((value) => ({ value, count: states.get(value) ?? 0 })),
+            };
+        },
+        taskPeople: async () => database
+            .prepare("SELECT p.id, p.name, p.owner, count(DISTINCT t.id) AS n FROM persons p " +
+            "LEFT JOIN task_assignments a ON a.assignee_type = 'person' AND a.assignee_id = p.id " +
+            "LEFT JOIN tasks t ON t.id = a.task_id AND t.deleted_at IS NULL " +
+            "WHERE p.owner = 1 OR t.id IS NOT NULL GROUP BY p.id ORDER BY p.owner DESC, p.name COLLATE NOCASE, p.id")
+            .all()
+            .map((row) => ({
+            person: `person:${row.id}`,
+            name: row.name == null ? null : String(row.name),
+            owner: Number(row.owner) === 1,
+            tasks: Number(row.n),
+        })),
         events: async (id) => database
-            .prepare("SELECT actor_type, actor_id, kind, changes, created_at FROM task_events WHERE task_id = ? ORDER BY id")
+            .prepare("SELECT e.actor_type, e.actor_id, e.kind, e.changes, e.created_at, " +
+            "CASE e.actor_type WHEN 'person' THEN p.name WHEN 'bot' THEN b.name END AS actor_name FROM task_events e " +
+            "LEFT JOIN persons p ON e.actor_type = 'person' AND p.id = e.actor_id " +
+            "LEFT JOIN bots b ON e.actor_type = 'bot' AND b.id = e.actor_id WHERE e.task_id = ? ORDER BY e.id")
             .all(required(id))
             .map((row) => ({
             kind: row.kind,
-            actor: row.actor_type == null ? null : { type: row.actor_type, id: Number(row.actor_id) },
+            actor: row.actor_type == null
+                ? null
+                : {
+                    type: row.actor_type,
+                    id: Number(row.actor_id),
+                    name: row.actor_name == null ? null : String(row.actor_name),
+                },
             changes: row.changes == null ? null : JSON.parse(String(row.changes)),
             at: iso(row.created_at),
         })),

package/dist/tasks/index.d.ts

@@ -1,3 +1,3 @@
-export { type ClosedState, closeTask, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, type Task, type TaskKind, type TaskOrigin, type TaskState, type TaskVerdict, } from "./model.js";
+export { CLOSED_STATES, type ClosedState, closeTask, isClosedState, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, type Task, type TaskKind, type TaskOrigin, type TaskState, type TaskVerdict, } from "./model.js";
 export { type CloseOptions, createTaskService, type GroupStats, type NewTask, type TaskService, type TaskServiceOptions, } from "./service.js";
 export { matches, type TaskFilter, type TaskStore } from "./store.js";

package/dist/tasks/index.js

@@ -1,3 +1,3 @@
-export { closeTask, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, } from "./model.js";
+export { CLOSED_STATES, closeTask, isClosedState, TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS, } from "./model.js";
 export { createTaskService, } from "./service.js";
 export { matches } from "./store.js";

package/dist/tasks/model.d.ts

@@ -1,12 +1,15 @@
 export declare const TASK_KINDS: readonly ["question", "request", "mention", "promise"];
-export declare const TASK_STATES: readonly ["open", "done", "dismissed"];
+/** `todo` and `in_progress` are steps of a project task's work; a task from a message is only ever open or closed. */
+export declare const TASK_STATES: readonly ["open", "todo", "in_progress", "done", "dismissed"];
+export declare const CLOSED_STATES: readonly ["done", "dismissed"];
 export declare const TASK_ORIGINS: readonly ["rule", "agent", "owner"];
 export declare const TASK_VERDICTS: readonly ["useful", "not_useful"];
 export type TaskKind = (typeof TASK_KINDS)[number];
 export type TaskState = (typeof TASK_STATES)[number];
 export type TaskOrigin = (typeof TASK_ORIGINS)[number];
 export type TaskVerdict = (typeof TASK_VERDICTS)[number];
-export type ClosedState = Exclude<TaskState, "open">;
+export type ClosedState = (typeof CLOSED_STATES)[number];
+export declare const isClosedState: (state: string) => state is ClosedState;
 /**
  * A task points at what it is about and never holds its text: `source` is a locator the host
  * resolves (`msg:…` for a message), so a deleted message leaves nothing behind here.

package/dist/tasks/model.js

@@ -1,10 +1,13 @@
 import { CliError } from "@wirecat/cli-base";
 export const TASK_KINDS = ["question", "request", "mention", "promise"];
-export const TASK_STATES = ["open", "done", "dismissed"];
+/** `todo` and `in_progress` are steps of a project task's work; a task from a message is only ever open or closed. */
+export const TASK_STATES = ["open", "todo", "in_progress", "done", "dismissed"];
+export const CLOSED_STATES = ["done", "dismissed"];
 export const TASK_ORIGINS = ["rule", "agent", "owner"];
 export const TASK_VERDICTS = ["useful", "not_useful"];
+export const isClosedState = (state) => CLOSED_STATES.includes(state);
 export function closeTask(task, state, by, at, reason) {
-    if (task.state !== "open")
+    if (isClosedState(task.state))
         throw new CliError("validation_error", `task ${task.id} is already ${task.state}`, { reason: "task.closed" });
     const { claimedBy: _by, claimedUntil: _until, ...unclaimed } = task;
     return { ...unclaimed, state, closedAt: at, closedBy: by, ...(reason === undefined ? {} : { reason }) };

package/dist/tasks/service.js

@@ -1,5 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
-import { closeTask } from "./model.js";
+import { closeTask, isClosedState } from "./model.js";
 export function createTaskService({ store, now = () => new Date(), newId = () => crypto.randomUUID(), }) {
     async function find(id) {
         const task = await store.get(id);
@@ -36,7 +36,7 @@ export function createTaskService({ store, now = () => new Date(), newId = () =>
             for (const task of await store.list(filter))
                 byGroup.set(task.group, [...(byGroup.get(task.group) ?? []), task]);
             return [...byGroup].map(([group, tasks]) => {
-                const open = tasks.filter((task) => task.state === "open");
+                const open = tasks.filter((task) => !isClosedState(task.state));
                 const closeMs = tasks.flatMap((task) => task.closedAt ? [task.closedAt.getTime() - task.createdAt.getTime()] : []);
                 const oldestOpenAt = open.map((task) => task.createdAt).sort((a, b) => a.getTime() - b.getTime())[0];
                 return {

package/package.json

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