@wirecat/cli-core 0.452.0 → 0.454.0

package/dist/store/sqlite/note-search.d.ts

@@ -1,5 +1,6 @@
 import type { ResolvedNode } from "../../search/lucene/resolved.js";
 import type { Stemmer } from "../../search/stem.js";
+import type { SqlValue } from "../driver.js";
 import { type DocumentPictureStore } from "./document-pictures.js";
 import { type NoteIndexState } from "./note-index.js";
 import { type Note } from "./notes.js";
@@ -28,11 +29,52 @@ export interface NoteHit {
 }
 /** The fields a note has. A message-only field (`from:`, `chat:`, …) is refused rather than matching nothing. */
 export declare const NOTE_FIELDS: readonly ["text", "exact", "body", "tag", "date", "in", "has", "title", "site", "lang", "author", "keyword", "source"];
+interface Fragment {
+    sql: string;
+    params: SqlValue[];
+    /** False when the SQL only narrows the candidates and a JS test decides. */
+    exact: boolean;
+    fts?: string;
+    stems?: string;
+}
+/**
+ * Files in notes folders, the notes the owner wrote and calendar events: one query language, each in its own table
+ * and index.
+ */
+export interface Corpus {
+    type: "document" | "note" | "event";
+    /** What a hit is called in an error and in `in:` (`in:notes`, `in:events`). */
+    noun: "note" | "event";
+    fields: readonly string[];
+    /** The rows as `n`, with the columns the query reads under one set of names; `at` is the time `date:` reads. */
+    view: string;
+    words: string;
+    stems: string;
+    /** The rows a search may return at all, besides `deleted_at`. */
+    live?: string;
+    /** The rows of these accounts, as a JSON list of ids. */
+    inAccounts?: (ids: string) => Fragment;
+    /** The tagged rows; a document is also labelled through its folder or a subfolder of it. */
+    tagged?: (tag: string) => Fragment;
+}
+export interface CorpusRow {
+    type: Corpus["type"];
+    id: number;
+    /** The time `date:` reads: a note's last change, an event's start. */
+    at: number | null;
+    relevance: number | null;
+    exact?: boolean;
+}
+/** What one corpus is searched by; `accountIds` narrows a corpus that has accounts. */
+export type CorpusQuery = Pick<NoteQuery, "root" | "limit" | "offset" | "newest" | "stemmer" | "signal"> & {
+    accountIds?: string[];
+};
 /** Notes matching a parsed query, by the same language as messages: files and written notes, merged. */
 export declare const searchNotes: (context: StoreContext, query: NoteQuery) => {
     items: NoteHit[];
     hasMore: boolean;
 };
+export declare const searchCorpus: (context: StoreContext, query: CorpusQuery, corpus: Corpus) => CorpusRow[];
 export interface NoteChunkToEmbed {
     hash: string;
     text: string;
@@ -75,3 +117,4 @@ export interface NoteSearch extends DocumentPictureStore {
     }): Promise<NearestNote[]>;
 }
 export declare const noteSearchOver: (context: StoreContext) => NoteSearch;
+export {};

package/dist/store/sqlite/note-search.js

@@ -40,9 +40,13 @@ const combine = (parts, operator) => ({
 const CORPORA = [
     {
         type: "document",
-        view: "(SELECT id, account_id AS folder_id, external_id AS path, title, coalesce(body, '') AS text, metadata, updated_at, deleted_at FROM documents)",
+        noun: "note",
+        fields: NOTE_FIELDS,
+        view: "(SELECT id, account_id AS folder_id, external_id AS path, title, coalesce(body, '') AS text, metadata, updated_at AS at, deleted_at FROM documents)",
         words: "document_words",
         stems: "document_stems",
+        live: "coalesce(json_extract(n.metadata, '$.catalog.active'), 1)=1",
+        inAccounts: (ids) => bound("n.folder_id IN (SELECT CAST(value AS INTEGER) FROM json_each(?))", ids),
         tagged: (tag) => bound("(n.id IN (SELECT g.taggable_id FROM taggings g JOIN resolved_tags t ON t.id=g.tag_id WHERE t.name = ? AND g.taggable_type = 'document') " +
             "OR n.folder_id IN (SELECT g.taggable_id FROM taggings g JOIN resolved_tags t ON t.id=g.tag_id WHERE t.name = ? AND g.taggable_type = 'account') " +
             "OR EXISTS (SELECT 1 FROM links l JOIN resolved_tags t ON t.id=l.to_id WHERE l.from_type = 'account' AND l.from_id = n.folder_id " +
@@ -50,7 +54,9 @@ const CORPORA = [
     },
     {
         type: "note",
-        view: "(SELECT id, NULL AS folder_id, NULL AS path, title, body AS text, NULL AS metadata, updated_at, deleted_at FROM notes)",
+        noun: "note",
+        fields: NOTE_FIELDS,
+        view: "(SELECT id, NULL AS folder_id, NULL AS path, title, body AS text, NULL AS metadata, updated_at AS at, deleted_at FROM notes)",
         words: "note_words",
         stems: "note_stems",
         tagged: (tag) => bound("n.id IN (SELECT g.taggable_id FROM taggings g JOIN resolved_tags t ON t.id=g.tag_id WHERE t.name = ? AND g.taggable_type = 'note')", tag),
@@ -61,14 +67,14 @@ export const searchNotes = (context, query) => {
     const offset = query.offset ?? 0;
     const chosen = CORPORA.filter(({ type }) => (query.source === undefined || (query.source === "file") === (type === "document")) &&
         (!query.folderIds?.length || query.withInternal === true || type === "document"));
-    const rows = chosen.flatMap((corpus) => searchCorpus(context, query, corpus));
+    const rows = chosen.flatMap((corpus) => searchCorpus(context, { ...query, ...(query.folderIds ? { accountIds: query.folderIds } : {}) }, corpus));
     const exactFirst = rows.some((row) => row.exact !== undefined);
     rows.sort((a, b) => query.newest
-        ? b.updatedAt - a.updatedAt || a.id - b.id
+        ? (b.at ?? 0) - (a.at ?? 0) || a.id - b.id
         : (exactFirst ? Number(b.exact === true) - Number(a.exact === true) : 0) ||
             Number(a.relevance === null) - Number(b.relevance === null) ||
             (a.relevance ?? 0) - (b.relevance ?? 0) ||
-            b.updatedAt - a.updatedAt ||
+            (b.at ?? 0) - (a.at ?? 0) ||
             a.id - b.id);
     const read = {
         document: context.database.prepare("SELECT * FROM documents WHERE id = ?"),
@@ -76,7 +82,7 @@ export const searchNotes = (context, query) => {
     };
     return {
         items: rows.slice(offset, offset + query.limit).map((row) => {
-            const found = read[row.type].get(row.id);
+            const found = read[row.type === "document" ? "document" : "note"].get(row.id);
             const note = row.type === "document" ? documentOf(found) : noteOf(found);
             return {
                 ref: note.ref,
@@ -88,7 +94,7 @@ export const searchNotes = (context, query) => {
         hasMore: rows.length > offset + query.limit,
     };
 };
-const searchCorpus = (context, query, corpus) => {
+export const searchCorpus = (context, query, corpus) => {
     const { database } = context;
     const wordMatch = (match) => ({
         sql: `n.id IN (SELECT rowid FROM ${corpus.words} WHERE ${corpus.words} MATCH ?)`,
@@ -116,8 +122,8 @@ const searchCorpus = (context, query, corpus) => {
         .map((row) => ({ id: Number(row.id), title: normalize(String(row.title)) })));
     const leaf = (node) => {
         const { field, operator, value } = node;
-        if (!NOTE_FIELDS.includes(field))
-            searchError("query.unsupported-field", node.span, `${field}: is not a note field — notes take ${NOTE_FIELDS.join(", ")}`);
+        if (!corpus.fields.includes(field))
+            searchError("query.unsupported-field", node.span, `${field}: is not ${corpus.noun === "event" ? "an" : "a"} ${corpus.noun} field — ${corpus.noun}s take ${corpus.fields.join(", ")}`);
         if ((field === "text" || field === "exact") && value === "")
             return bound("0");
         if (isStemmed(node)) {
@@ -168,7 +174,7 @@ const searchCorpus = (context, query, corpus) => {
             if (tag === undefined)
                 searchError("query.invalid-tag", node.span);
             // A label on a folder or subfolder labels every note under it, at any depth.
-            return corpus.tagged(canonicalTagNamed(database, tag)?.name ?? tag);
+            return corpus.tagged?.(canonicalTagNamed(database, tag)?.name ?? tag) ?? bound("0");
         }
         if (field === "source")
             return bound(value.toLowerCase() === (corpus.type === "note" ? "internal" : "file") ? "1" : "0");
@@ -199,15 +205,11 @@ const searchCorpus = (context, query, corpus) => {
             if (!range)
                 searchError("query.invalid-ast", node.span);
             return combine([
-                ...(range.lower === undefined
-                    ? []
-                    : [bound(`n.updated_at ${range.lower_inclusive ? ">=" : ">"} ?`, range.lower)]),
-                ...(range.upper === undefined
-                    ? []
-                    : [bound(`n.updated_at ${range.upper_inclusive ? "<=" : "<"} ?`, range.upper)]),
+                ...(range.lower === undefined ? [] : [bound(`n.at ${range.lower_inclusive ? ">=" : ">"} ?`, range.lower)]),
+                ...(range.upper === undefined ? [] : [bound(`n.at ${range.upper_inclusive ? "<=" : "<"} ?`, range.upper)]),
             ], "AND");
         }
-        return bound(["notes", "note"].includes(value.toLowerCase()) ? "1" : "0");
+        return bound([corpus.noun, `${corpus.noun}s`].includes(value.toLowerCase()) ? "1" : "0");
     };
     const compile = (node) => {
         if (node.kind === "predicate") {
@@ -243,10 +245,8 @@ const searchCorpus = (context, query, corpus) => {
         const stemmed = [...fragments.keys()].some(isStemmed);
         const scope = combine([
             bound("n.deleted_at IS NULL"),
-            ...(corpus.type === "document" ? [bound("coalesce(json_extract(n.metadata, '$.catalog.active'), 1)=1")] : []),
-            ...(query.folderIds?.length && corpus.type === "document"
-                ? [bound("n.folder_id IN (SELECT CAST(value AS INTEGER) FROM json_each(?))", JSON.stringify(query.folderIds))]
-                : []),
+            ...(corpus.live ? [bound(corpus.live)] : []),
+            ...(query.accountIds?.length && corpus.inAccounts ? [corpus.inAccounts(JSON.stringify(query.accountIds))] : []),
         ], "AND");
         const where = combine([scope, expression], "AND");
         const ranking = query.newest ? undefined : required(query.root, stemmed ? "stems" : "fts");
@@ -263,8 +263,8 @@ const searchCorpus = (context, query, corpus) => {
             cteParams.push(`normalized_text : (${exactTier})`);
         }
         const order = query.newest
-            ? "n.updated_at DESC, n.id"
-            : `${exactTier ? "exact DESC, " : ""}${ranking ? "f.rank IS NULL, f.rank, " : ""}n.updated_at DESC, n.id`;
+            ? "n.at DESC, n.id"
+            : `${exactTier ? "exact DESC, " : ""}${ranking ? "f.rank IS NULL, f.rank, " : ""}n.at DESC, n.id`;
         const offset = query.offset ?? 0;
         // With a JS test the SQL only names candidates: every leaf's SQL answer comes along, so the test sees it.
         const leaves = [...fragments.entries()].filter(([node]) => !tests.has(node));
@@ -304,7 +304,7 @@ const searchCorpus = (context, query, corpus) => {
         return matched.map((row) => ({
             type: corpus.type,
             id: Number(row.id),
-            updatedAt: Number(row.updated_at),
+            at: row.at == null ? null : Number(row.at),
             relevance: row.relevance === null || row.relevance === undefined ? null : Number(row.relevance),
             ...(exactTier ? { exact: Number(row.exact) === 1 } : {}),
         }));

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

@@ -2,13 +2,13 @@ import type { Section } from "../../readers/types.js";
 import type { CacheDatabase } from "../driver.js";
 import { type DocumentMetadata } from "./document-metadata.js";
 import { type ImportedDocuments } from "./imported-documents.js";
-import { LINK_KINDS } from "./link-kinds.js";
+import { LINK_KINDS, LINK_ORIGINS, type LINK_SOURCES } from "./link-kinds.js";
 import type { NoteSearch } from "./note-search.js";
 import type { StoreContext } from "./open.js";
 import { type Label } from "./tags.js";
 import { type Thing } from "./things.js";
 export declare const NOTE_FORMATS: readonly ["obsidian", "markdown"];
-export declare const LINK_ORIGINS: readonly ["file", "owner", "suggested", "message"];
+export { LINK_ORIGINS } from "./link-kinds.js";
 /**
  * A notes folder: an `accounts` row of provider `local` or `obsidian`. Where it is on disk is this computer's config. A
  * documents account (Drive's, one per Google account) is read and written the same way and names its `account`.
@@ -52,7 +52,7 @@ export interface Link {
     to: string | null;
     kind: (typeof LINK_KINDS)[number];
     anchor: string | null;
-    origin: (typeof LINK_ORIGINS)[number];
+    origin: (typeof LINK_SOURCES)[number];
     targetText: string | null;
     role: string | null;
     evidence: string | null;
@@ -76,7 +76,7 @@ export interface LinkInput {
     targetText?: string;
     kind: Link["kind"];
     anchor?: string;
-    origin?: Link["origin"];
+    origin?: (typeof LINK_ORIGINS)[number];
     role?: string;
     evidence?: string;
     provenance?: string;
@@ -193,4 +193,3 @@ export declare const resolvePersonLinks: (database: CacheDatabase, names: (strin
 /** Writes one link; an identical resolved link is answered instead of doubled. */
 export declare const insertLink: (context: StoreContext, input: LinkInput) => Link;
 export declare const notesStoreOver: (context: StoreContext) => Omit<NotesStore, keyof NoteSearch>;
-export {};

package/dist/store/sqlite/notes.js

@@ -10,13 +10,13 @@ import { ownerPerson } from "./actors.js";
 import { encodeDocumentMetadata, languageOf } from "./document-metadata.js";
 import { PREFERRED_FILE, syncFile } from "./files.js";
 import { importedDocumentWhere } from "./imported-documents.js";
-import { LINK_KINDS, linkKind } from "./link-kinds.js";
+import { LINK_KINDS, LINK_ORIGINS, linkKind } from "./link-kinds.js";
 import { reviewLink } from "./link-reviews.js";
 import { addTags, ensureTag, labelsOf } from "./tags.js";
 import { canonicalThingReference, referenceOfThing, storedThing, thingOf } from "./things.js";
 import { write } from "./transaction.js";
 export const NOTE_FORMATS = ["obsidian", "markdown"];
-export const LINK_ORIGINS = ["file", "owner", "suggested", "message"];
+export { LINK_ORIGINS } from "./link-kinds.js";
 const iso = (value) => new Date(Number(value)).toISOString();
 const optionalIso = (value) => (value == null ? null : iso(value));
 const textOf = (text, what, max = 100_000, allowEmpty = false) => {

package/dist/store/sqlite/project-transfer/snapshot.d.ts

@@ -23,7 +23,7 @@ export declare const projectAnnotationSnapshot: (database: CacheDatabase, projec
             ref: string;
             from: string;
             to: string | null;
-            kind: "about" | "answered-by" | "assigned-to" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
+            kind: "about" | "answered-by" | "assigned-to" | "attached" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
             origin: "file" | "message" | "owner" | "suggested";
             anchor: string | null;
             target_text: string | null;

package/dist/store/store.d.ts

@@ -20,6 +20,7 @@ import { type AgentActionsStore } from "./sqlite/agent-actions.js";
 import { type BotUpdateStore } from "./sqlite/bot-updates.js";
 import { type CatalogStore } from "./sqlite/catalog.js";
 import { type MailStore } from "./sqlite/emails.js";
+import { type EventSearch } from "./sqlite/event-search.js";
 import { type FactsStore } from "./sqlite/facts.js";
 import { type FilesStore } from "./sqlite/files.js";
 import { type InvolvementStore } from "./sqlite/involvements.js";
@@ -84,7 +85,7 @@ export interface MessageStore {
     /** Where each document is kept: its files, their folders and paths. */
     readonly files: FilesStore;
     /** Calendars and their entries, the source records of events: the `EventStore` a calendar CLI writes through. */
-    readonly calendar: EventStore;
+    readonly calendar: EventStore & EventSearch;
     /** Choices that hold until replaced, each with its evidence. */
     readonly meetingFindings: MeetingFindingsStore;
     /** Cited facts and follow-ups about one project from stored messages, mail and documents, for review. */

package/dist/store/store.js

@@ -19,6 +19,7 @@ import { eventStoreOver } from "./sqlite/calendar.js";
 import { catalogStoreOver } from "./sqlite/catalog.js";
 import { contextEvidenceOver, contextIndexOver, contextRecordsOver } from "./sqlite/context-evidence.js";
 import { mailStoreOver } from "./sqlite/emails.js";
+import { eventSearchOver } from "./sqlite/event-search.js";
 import { evidenceFindingsStoreOver } from "./sqlite/evidence-findings.js";
 import { factsStoreOver } from "./sqlite/facts.js";
 import { filesStoreOver } from "./sqlite/files.js";
@@ -100,7 +101,7 @@ const storeOver = (context) => {
     const notes = once(() => ({ ...notesStoreOver(context), ...noteSearchOver(context) }));
     const catalog = once(() => catalogStoreOver(context));
     const files = once(() => filesStoreOver(context));
-    const calendar = once(() => eventStoreOver(context));
+    const calendar = once(() => ({ ...eventStoreOver(context), ...eventSearchOver(context) }));
     const meetingFindings = once(() => meetingFindingsStoreOver(context));
     const evidenceFindings = once(() => evidenceFindingsStoreOver(context));
     const facts = once(() => factsStoreOver(context));

package/package.json

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