@wirecat/cli-core 0.412.0 → 0.414.0

package/dist/services/project-gathering.js

@@ -5,6 +5,7 @@ import { excerpt } from "./excerpt.js";
 import { attachNeighbours, documentMatches, } from "./project-gathering-around.js";
 import { decodeCheckpoint, encodeCheckpoint, projectGatheringRequest, projectUnits, seenKey, } from "./project-gathering-request.js";
 const terminal = new Set(["done", "unavailable", "failed"]);
+const PAGE = 20;
 const CONTEXTS = ["person-only", "sender", "linked-chat", "project"];
 const contextOf = (lane) => lane.kinds.includes("linked-chat")
     ? "linked-chat"
@@ -84,6 +85,12 @@ export const gatherProjectEvidence = async (ports, request) => {
     const oversized = new Map();
     let stopped = null;
     const open = (u) => !terminal.has(u.state) && u.state !== "read-limited";
+    const linkedLanes = new Set(plan.linkedChats.flatMap((c) => (c.lane === null ? [] : [c.lane])));
+    // One even share per linked chat plus one for the word and sender lanes, so one busy chat cannot fill a run; never
+    // below a page, so every chat still gets its whole first page.
+    const linkedLimit = Math.max(PAGE, Math.floor(plan.budgets.maxItems / (linkedLanes.size + 1)));
+    const linkedTaken = new Map();
+    const capped = new Set();
     /** Records another lane finding a reference this run already returned; true when it had. */
     const again = (ref, lane) => {
         const known = byRef.get(ref);
@@ -133,11 +140,13 @@ export const gatherProjectEvidence = async (ports, request) => {
         byRef.set(item.ref, entry);
         items.push(entry);
         usage.items++;
+        if (linkedLanes.has(lane.id))
+            linkedTaken.set(lane.id, (linkedTaken.get(lane.id) ?? 0) + 1);
     };
     // A resumed run starts at its shallowest open unit: below it no unit is due, and an empty round would end the run.
     const shallowest = progress.reduce((low, u) => (open(u) ? Math.min(low, u.pages) : low), Number.POSITIVE_INFINITY);
     for (let round = shallowest; !stopped; round++) {
-        const due = progress.flatMap((u, index) => (open(u) && u.pages <= round ? [index] : []));
+        const due = progress.flatMap((u, index) => open(u) && u.pages <= round && !capped.has(units[index]?.lane.id ?? "") ? [index] : []);
         if (!due.length)
             break;
         for (const index of due) {
@@ -145,6 +154,11 @@ export const gatherProjectEvidence = async (ports, request) => {
             if (!unit || !state)
                 continue;
             signal?.throwIfAborted();
+            const room = linkedLanes.has(unit.lane.id) ? linkedLimit - (linkedTaken.get(unit.lane.id) ?? 0) : PAGE;
+            if (room <= 0) {
+                capped.add(unit.lane.id);
+                continue;
+            }
             stopped =
                 usage.reads >= plan.budgets.maxReads
                     ? "reads"
@@ -187,7 +201,7 @@ export const gatherProjectEvidence = async (ports, request) => {
                 }
             };
             try {
-                let page = await readPage(Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes), 20);
+                let page = await readPage(Math.min(plan.budgets.maxPageBytes, plan.budgets.maxReadBytes - usage.readBytes), Math.min(PAGE, room));
                 // A large record another lane already returned is not read again; its page already moves past it.
                 const big = page.oversized && !again(page.oversized.ref, unit.lane) ? page.oversized : undefined;
                 if (big && big.bytes <= CONTEXT_MAX_READ_BYTES) {
@@ -288,6 +302,8 @@ export const gatherProjectEvidence = async (ports, request) => {
                 : units.every((unit, index) => unit.lane.id !== lane || progress[index]?.state === "unavailable")
                     ? "unavailable"
                     : "in-scope",
+            items: lane === null ? 0 : (linkedTaken.get(lane) ?? 0),
+            capped: lane !== null && capped.has(lane),
         })),
         fetch: fetched.map((f, index) => ({ source: index, ...f })),
         index: indexed,

package/dist/store/people.js

@@ -12,8 +12,11 @@ export const accountPeopleOver = (context) => {
     return {
         savePeople: async (key, people) => write(database, () => {
             const accountKey = accountPk(key);
-            for (const person of people)
+            for (const person of people) {
                 identityPk(accountKey, key.provider, person.id, person.name, person);
+                if (person.email)
+                    personLinks.joinByAddress(context, { provider: key.provider, id: person.id }, person.email, key.provider);
+            }
         }),
         contacts: async (key, options) => {
             const accountKey = findAccountPk(key);

package/dist/store/sqlite/person-links.d.ts

@@ -14,6 +14,12 @@ export declare const linkIdentityToPerson: (context: StoreContext, identityPk: n
 export declare const linkIdentities: (context: StoreContext, person: IdentityRef, other: IdentityRef, options: LinkOptions) => PersonRecord;
 /** Moves every identity of `from` to `to`, as `linkIdentities` does once it has found both people. */
 export declare const mergePerson: (context: StoreContext, from: number, to: number, options: LinkOptions) => void;
+/**
+ * Joins the identity to the person of the mail contact with this exact address, making that contact when mail has
+ * not seen it yet, so whichever import comes second lands on one person. The contact is seen by no account, so it is
+ * no one's mail correspondent. An owner's unlink wins: two identities the owner separated stay apart.
+ */
+export declare const joinByAddress: (context: StoreContext, ref: IdentityRef, address: string, by: string) => void;
 /** Gives the identity a person of its own again; the ones left keep theirs. */
 export declare const unlinkIdentity: (context: StoreContext, ref: IdentityRef, options: LinkOptions) => PersonRecord;
 /** Messages that name the person: by id where the messenger said so, or by `@username` in the text. */

package/dist/store/sqlite/person-links.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, eq, inArray, isNull, sql } from "./drizzle/core.js";
+import { identityOf } from "./identities.js";
 import { resolvePersonLinks } from "./person-resolution.js";
 import { accountIdentities, accounts, chats, identities, identityLinkEvents, identityLinks, messages, persons, } from "./schema.js";
 import { hitsWhere } from "./search.js";
@@ -135,6 +136,32 @@ export const mergePerson = (context, from, to, options) => {
     for (const { identityPk } of together)
         move(context, identityPk, from, to, options);
 };
+/** The owner once moved one of the two identities away from a person the other belonged to. */
+const separatedByOwner = ({ database }, one, other) => database
+    .prepare(`SELECT 1 FROM identity_link_events moved
+       JOIN identity_link_events held ON held.to_person_id = moved.from_person_id
+       WHERE moved.author = 'owner' AND ((moved.identity_id = ? AND held.identity_id = ?)
+         OR (moved.identity_id = ? AND held.identity_id = ?))
+       LIMIT 1`)
+    .get(one, other, other, one) !== undefined;
+/**
+ * Joins the identity to the person of the mail contact with this exact address, making that contact when mail has
+ * not seen it yet, so whichever import comes second lands on one person. The contact is seen by no account, so it is
+ * no one's mail correspondent. An owner's unlink wins: two identities the owner separated stay apart.
+ */
+export const joinByAddress = (context, ref, address, by) => {
+    const key = address.trim().toLowerCase();
+    if (!/^[^\s@]+@[^\s@]+$/.test(key) || ref.provider === "email")
+        return;
+    const found = required(context, ref);
+    if (!identityRow(context, { provider: "email", id: key }))
+        identityOf(context, "email", key, null);
+    const contact = required(context, { provider: "email", id: key });
+    if (contact.personPk === found.personPk || separatedByOwner(context, found.pk, contact.pk))
+        return;
+    mergePerson(context, found.personPk, contact.personPk, { method: "same-email", by });
+    resolvePersonLinks(context.database, recordOf(context, contact.personPk).identities.flatMap(({ name, username }) => [name, username]));
+};
 /** Gives the identity a person of its own again; the ones left keep theirs. */
 export const unlinkIdentity = (context, ref, options) => {
     const found = required(context, ref);

package/dist/store/types.d.ts

@@ -32,6 +32,8 @@ export interface PersonFacts {
     username?: string | null;
     isBot?: boolean | null;
     description?: string | null;
+    /** An address the provider shows for them: they become one person with the mail contact of that exact address. */
+    email?: string | null;
 }
 /** One identity in one messenger, by the messenger's own id. `provider` is any string: `email` is one. */
 export interface IdentityRef {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.412.0",
+  "version": "0.414.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",
@@ -128,6 +128,10 @@
     "./update": {
       "types": "./dist/update/index.d.ts",
       "default": "./dist/update/index.js"
+    },
+    "./oauth": {
+      "types": "./dist/oauth/index.d.ts",
+      "default": "./dist/oauth/index.js"
     }
   },
   "scripts": {