@wirecat/cli-core 0.419.0 → 0.421.0

package/dist/services/document-source.d.ts

@@ -1,7 +1,11 @@
 import type { Profiles } from "../search/account-list.js";
-import type { Note, NoteFolder } from "../store/index.js";
-/** Imported sources keep their remote edit time; indexing time still belongs to the local row. */
-export declare const documentSource: (note: Note, folders: NoteFolder[], profiles: Profiles) => {
+import type { Note, StoredAccount, StoredFile } from "../store/index.js";
+/**
+ * Where a hit came from. The document's preferred file says it: its account's provider, its link and its edit time.
+ * A Drive document under a notes folder (before version 31 moves it) is still known by its front matter.
+ * Indexing time belongs to the local row.
+ */
+export declare const documentSource: (note: Note, accounts: readonly StoredAccount[], profiles: Profiles, file?: StoredFile) => {
     kind: "document" | "note";
     provider: string;
     account: string;

package/dist/services/document-source.js

@@ -1,18 +1,30 @@
-/** Imported sources keep their remote edit time; indexing time still belongs to the local row. */
-export const documentSource = (note, folders, profiles) => {
+import { isFolderProvider, kindIn } from "../domain/providers.js";
+/**
+ * Where a hit came from. The document's preferred file says it: its account's provider, its link and its edit time.
+ * A Drive document under a notes folder (before version 31 moves it) is still known by its front matter.
+ * Indexing time belongs to the local row.
+ */
+export const documentSource = (note, accounts, profiles, file) => {
     const metadata = note.frontMatter;
-    const folder = folders.find(({ id }) => id === note.folderId);
-    const remote = note.source === "file" && metadata?.source === "google-drive";
-    const profile = remote && folder
-        ? Object.entries(profiles.drive ?? {}).find(([, key]) => key.provider === "folder" && key.account === folder.name)?.[0]
+    const account = accounts.find(({ id }) => String(id) === note.folderId);
+    const remote = note.source === "file" &&
+        ((account !== undefined && kindIn(account.provider) === "documents") || metadata?.source === "google-drive");
+    const profile = remote && account
+        ? Object.entries(profiles)
+            .flatMap(([command, named]) => Object.entries(named).map(([name, key]) => ({ command, name, key })))
+            .find(({ key }) => (key.provider === account.provider && key.account === account.account) ||
+            (isFolderProvider(key.provider) && key.account === account.name))
         : undefined;
+    const url = file?.url ?? (remote && typeof metadata?.sourceUrl === "string" ? metadata.sourceUrl : undefined);
+    const modified = file?.externalUpdatedAt ??
+        (remote && typeof metadata?.modifiedAt === "string" && Number.isFinite(Date.parse(metadata.modifiedAt))
+            ? metadata.modifiedAt
+            : undefined);
     return {
         kind: remote ? "document" : "note",
-        provider: profile ? "drive" : "notes",
-        account: profile ?? note.folderId ?? "internal",
-        ...(remote && typeof metadata?.sourceUrl === "string" ? { url: metadata.sourceUrl } : {}),
-        updated_at: remote && typeof metadata?.modifiedAt === "string" && Number.isFinite(Date.parse(metadata.modifiedAt))
-            ? metadata.modifiedAt
-            : note.updatedAt,
+        provider: profile ? profile.command : "notes",
+        account: profile?.name ?? note.folderId ?? "internal",
+        ...(remote && url !== undefined ? { url } : {}),
+        updated_at: remote && modified !== undefined ? modified : note.updatedAt,
     };
 };

package/dist/services/documents/ingestion.d.ts

@@ -1,7 +1,12 @@
 import type { SourceContent, SourceFile } from "../../documents/model.js";
 import type { CatalogInput, CatalogQuery, MessageStore } from "../../store/index.js";
 export interface IngestionOptions<M extends SourceFile> {
-    collectionName(principal: string): string;
+    /**
+     * The documents account's provider (`google-drive`): each principal's documents live under
+     * `{ provider, account: principal }`. Without it they live in a notes folder named `collectionName(principal)`.
+     */
+    provider?: string;
+    collectionName?(principal: string): string;
     externalId(id: string): string;
     catalogInput(file: M): CatalogInput;
     frontMatter(content: SourceContent<M>): Record<string, unknown>;

package/dist/services/documents/ingestion.js

@@ -2,6 +2,10 @@ import { CliError } from "@wirecat/cli-base";
 import { walkQuery } from "@wirecat/cli-base/query";
 export const documentIngestion = (store, options) => {
     const folder = async (principal, create) => {
+        if (options.provider)
+            return store.notes.documentsAccount({ provider: options.provider, account: principal }, create);
+        if (!options.collectionName)
+            throw new CliError("configuration_error", "document ingestion needs a provider or a collection name");
         const name = options.collectionName(principal);
         const found = (await store.notes.folders()).find((item) => item.name === name);
         return found ?? (create ? await store.notes.addFolder({ name, format: "markdown" }) : undefined);

package/dist/services/notes-search.js

@@ -295,7 +295,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
     const hasMore = slice ? matched.hasMore : ordered.length > window || matched.hasMore || titled.hasMore;
     const hits = [];
     const counts = new Map();
-    const folders = await store.notes.folders();
+    const accounts = await store.accounts.storedAccounts();
     const profiles = await store.accounts.profiles();
     for (const [ref, { note, foundBy }] of page) {
         const links = (await store.notes.links({ from: ref })).map(({ to, targetText, kind, anchor }) => ({
@@ -310,7 +310,7 @@ export const searchNotes = async (store, query, { limit = 20, offset = 0, tag, f
             folder_id: note.folderId,
             path: note.path,
             title: note.title,
-            ...documentSource(note, folders, profiles),
+            ...documentSource(note, accounts, profiles, note.source === "file" ? (await store.files.ofDocument(note.ref))[0] : undefined),
             excerpt: firstLine(note.text, words),
             links,
             found_by: foundBy,
@@ -374,6 +374,7 @@ export const searchNotesOf = async (store, account, text, { accounts: list, app,
     const held = [
         { provider: "notes", account: INTERNAL_NOTES },
         ...(await store.notes.folders()).map(({ id }) => ({ provider: "notes", account: id })),
+        ...(await store.notes.documentsAccounts()).map(({ id }) => ({ provider: "notes", account: id })),
     ];
     const named = list === undefined
         ? { accounts: held, skipped: [] }

package/dist/services/search-all.js

@@ -109,6 +109,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                 const read = chosen?.map(({ account }) => account) ?? [
                     INTERNAL_NOTES,
                     ...(await store.notes.folders()).map(({ id }) => id),
+                    ...(await store.notes.documentsAccounts()).map(({ id }) => id),
                 ];
                 accounts.push(...read.map((account) => ({ resource, provider: "notes", account })));
             }

package/dist/services/task-tag-filters.d.ts

@@ -0,0 +1,3 @@
+import { type QueryAst } from "@wirecat/cli-base/query";
+import type { MessageStore, Where } from "../store/store.js";
+export declare const taskTagFilters: (store: MessageStore, query: QueryAst | undefined) => Promise<Map<string, Where>>;

package/dist/services/task-tag-filters.js

@@ -0,0 +1,8 @@
+import { walkQuery } from "@wirecat/cli-base/query";
+export const taskTagFilters = async (store, query) => {
+    const tags = new Map();
+    for (const node of query ? walkQuery(query.root) : [])
+        if (node.field === "tag" && !tags.has(node.value))
+            tags.set(node.value, await store.tasks.tagWhere(node.value));
+    return tags;
+};

package/dist/services/tasks.js

@@ -9,6 +9,7 @@ import { createTaskService, TASK_KINDS, TASK_STATES, } from "../tasks/index.js";
 import { storedChatId } from "./message-resolution.js";
 import { categorize, taskCategoryOf } from "./task-categories.js";
 import { taskAccount } from "./task-rules.js";
+import { taskTagFilters } from "./task-tag-filters.js";
 export { TASK_KINDS, TASK_STATES };
 export const TASK_QUERY = {
     entity: "task",
@@ -68,17 +69,11 @@ export const TASK_PAIR_QUERY = {
 };
 const TIME = (sql) => ({ type: "time", sql });
 /** `chat:` names the chat as the messenger does; `groups` holds each name already resolved to its stored id. */
-const taskColumns = (groups) => ({
+const taskColumns = (groups, tags) => ({
     id: { type: "kw", sql: "t.package_id" },
     key: { type: "kw", sql: "t.key" },
     category: { type: "kw", sql: "t.category" },
-    tag: {
-        where: (node) => ({
-            sql: "EXISTS (SELECT 1 FROM taggings g JOIN tags n ON n.id = g.tag_id " +
-                "WHERE g.taggable_type = 'task' AND g.taggable_id = t.id AND n.name = ?)",
-            params: [node.value.trim().toLowerCase()],
-        }),
-    },
+    tag: { where: (node) => tags.get(node.value) ?? { sql: "0", params: [] } },
     title: { type: "kw", sql: "t.title_folded", folded: true },
     kind: { type: "enum", sql: "t.type" },
     state: { type: "enum", sql: "t.status" },
@@ -213,7 +208,8 @@ export const tasksService = (deps, categories) => {
             for (const node of query ? walkQuery(query.root) : [])
                 if (node.field === "chat" && node.operator !== "wildcard" && !groups.has(node.value))
                     groups.set(node.value, await storedChatId(deps.messenger, node.value, store, account, { includeLeft: true }));
-            const where = query ? queryFilter(query, taskColumns(groups), { command: "tasks list" }) : undefined;
+            const tags = await taskTagFilters(store, query);
+            const where = query ? queryFilter(query, taskColumns(groups, tags), { command: "tasks list" }) : undefined;
             const rows = await store.tasks.query(taskAccount(account), where, { limit: limit + 1, offset });
             const shown = rows.slice(0, limit);
             return {

package/dist/store/document-transfer/index.js

@@ -7,6 +7,7 @@ import { planTransfer } from "../sqlite/document-transfer/plan.js";
 import { transferSnapshot } from "../sqlite/document-transfer/snapshot.js";
 import { openSqlite } from "../sqlite/open.js";
 import { openStoreContext } from "../sqlite/open-store.js";
+import { assertReadCompatible } from "../sqlite/read-compatibility.js";
 import { digest } from "./digest.js";
 const locations = (options) => {
     for (const value of [options.source, options.destination, options.collection])
@@ -51,8 +52,17 @@ const openSource = async (path) => {
     }
 };
 const openPreviewTarget = async (path) => {
-    if (statSync(path, { throwIfNoEntry: false }))
-        return openSource(path);
+    if (statSync(path, { throwIfNoEntry: false })) {
+        const opened = await openSource(path);
+        try {
+            assertReadCompatible(opened.database);
+            return opened;
+        }
+        catch (error) {
+            opened.database.close();
+            throw error;
+        }
+    }
     const target = await openSqlite(":memory:");
     try {
         migrate(target.database);

package/dist/store/index.d.ts

@@ -1,6 +1,6 @@
 export type { ContextEvidenceItem, ContextEvidencePage, ContextEvidenceReader, ContextEvidenceRequest, ContextEvidenceSender, ContextSource, } from "../context/evidence.js";
 export { FACT_STATUSES, FACT_TYPES, MEMORY_KINDS, MEMORY_SCOPES, MEMORY_STATUSES, TASK_TYPES, WORK_TASK_TYPES, } from "../domain/knowledge.js";
-export type { TagConsolidationOptions, TagConsolidationPreview, TagConsolidationStore, } from "../domain/tag-consolidation.js";
+export type { TagConsolidationApplyOptions, TagConsolidationOptions, TagConsolidationPreview, TagConsolidationReceipt, TagConsolidationStore, } from "../domain/tag-consolidation.js";
 export type { TagRedirectIndex, TagRedirectResolution, TagRedirectSnapshot } from "../domain/tag-redirects.js";
 export { createTagRedirectIndex } from "../domain/tag-redirects.js";
 export { note } from "../entities/note.js";
@@ -31,6 +31,7 @@ export { CATALOG_QUERY } from "./sqlite/catalog.js";
 export type { ChatMetadata } from "./sqlite/chats.js";
 export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
 export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
+export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";
 export type { Involvement, InvolvementStore } from "./sqlite/involvements.js";
 export type { Annotation, KnowledgeRelation, KnowledgeStore, KnowledgeTarget, LabelledType, Organization, Project, Reminder, } from "./sqlite/knowledge.js";

package/dist/store/sqlite/accounts.js

@@ -111,6 +111,7 @@ export const purgeAccount = ({ orm, database }, accountKey) => {
     orm.delete(accountIdentities).where(eq(accountIdentities.accountId, accountKey)).run();
     // The inbox project and its tasks are the owner's; only the tie to the account goes.
     orm.update(projects).set({ accountId: null }).where(eq(projects.accountId, accountKey)).run();
+    orm.run(sql `DELETE FROM files WHERE account_id = ${accountKey}`);
     orm.delete(accounts).where(eq(accounts.id, accountKey)).run();
     dropOrphanPeople(database, unseenBefore);
     orm.run(sql `DELETE FROM embeddings WHERE content_hash IN (SELECT value FROM json_each(${JSON.stringify(hashes)}))

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

@@ -0,0 +1,3 @@
+import { type EventStore } from "../../meetings/index.js";
+import type { StoreContext } from "./open.js";
+export declare const eventStoreOver: (context: StoreContext) => EventStore;