@wirecat/cli-core 0.382.0 → 0.384.0

package/dist/cli/messenger/review.js

@@ -45,7 +45,7 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
     const hearWith = modelWith(options.transcribe, options.model);
     const context = messengerContext(this, messenger);
     const { settings, renderer, format, env } = context;
-    const { since: from, chat } = catchUpQuery(query, REVIEW_QUERY, "review");
+    const { since: from, chat, meta } = catchUpQuery(query, REVIEW_QUERY, "review");
     if (options.new && (from !== undefined || options.unanswered !== undefined)) {
         // An open question stays open: moving past it would drop it from the next review.
         throw new CliError("validation_error", "--new keeps its own point — not with a date or --unanswered");
@@ -96,6 +96,7 @@ export const reviewCommand = (messenger) => annotate(new Command("review"), {
         transcribe,
         fresh: saved !== undefined,
         ...(chat === undefined ? {} : { chat }),
+        ...(meta === undefined ? {} : { meta }),
     }), () => {
         const read = found.chats
             .flatMap((one) => one.messages.map((message) => ({ ...message, chatTitle: one.title })))

package/dist/cli/messenger/stats-answers.d.ts

@@ -67,7 +67,7 @@ export declare const chartAnswer: (chart: ChartData, file?: {
 /** A report or a chart is one object: `--jsonl` would print one line pretending to be a stream. */
 export declare const refuseJsonl: (format: string) => void;
 /** `stats chats show`, CLI and MCP alike; a chat the store does not hold whole names the sync that fills it. */
-export declare const chatStatsAnswer: (stats: ChatStats, account: AccountKey) => ItemBody<Of<"chat_stats">>;
+export declare const chatStatsAnswer: (stats: ChatStats, account: AccountKey, meta?: Partial<Meta>) => ItemBody<Of<"chat_stats">>;
 /** Said where the store has kept no join, leave or other chat event for the chat: a 0 would read as nobody joined. */
 export declare const MEMBERS_UNRECORDED = "joins and leaves are not recorded for this chat yet, so they are not counted";
 /** `stats tasks show`, CLI and MCP alike. */

package/dist/cli/messenger/stats-answers.js

@@ -167,7 +167,7 @@ export const adminAnswer = (found) => {
         rows,
     }, {
         next: drilldownSteps(top?.drilldown, top?.drilldown.arguments.component, top?.message ?? (top?.id.startsWith("msg:") ? top.id : undefined)),
-        ...truncated(found.hasMore),
+        meta: { ...found.timeMeta, ...(found.hasMore ? { truncated: true } : {}) },
     });
 };
 const cohortRow = (row) => ({
@@ -221,7 +221,7 @@ export const retentionAnswer = (found) => {
         rows: found.items.map(cohortRow),
     }, {
         next: drilldownSteps(top?.drilldown, top?.drilldown.arguments.component),
-        ...truncated(found.hasMore),
+        meta: { ...found.timeMeta, ...(found.hasMore ? { truncated: true } : {}) },
     });
 };
 const evidenceMessage = (hit) => ({
@@ -335,7 +335,7 @@ export const refuseJsonl = (format) => {
         });
 };
 /** `stats chats show`, CLI and MCP alike; a chat the store does not hold whole names the sync that fills it. */
-export const chatStatsAnswer = (stats, account) => {
+export const chatStatsAnswer = (stats, account, meta) => {
     const { chatId, completeness, topPosts, questions, memberCounts, members, series, fetch } = stats;
     const item = defined({
         chat: chatRef(account, chatId),
@@ -405,6 +405,7 @@ export const chatStatsAnswer = (stats, account) => {
         ...(completeness.state === "complete" || fetch === undefined
             ? {}
             : { next: [nextStep("messages.sync", { args: { chat: chatId } })] }),
+        ...(meta ? { meta } : {}),
     });
 };
 /** Said where the store has kept no join, leave or other chat event for the chat: a 0 would read as nobody joined. */

package/dist/cli/runs/search.d.ts

@@ -42,6 +42,13 @@ export declare const searchRuns: (dir: string, { query, status, errorCode, opera
     page: number;
     limit: number;
     hasMore: boolean;
+    meta: {
+        timezone?: string;
+        window?: {
+            since?: string;
+            until?: string;
+        };
+    };
 };
 /** A page of `searchRuns` in the list envelope; `args` are the search's own, so `page.next` reruns it. */
 export declare const runsFound: (found: ReturnType<typeof searchRuns>, args: Record<string, unknown>) => import("../envelope.js").ListBody<unknown>;

package/dist/cli/runs/search.js

@@ -1,6 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { findRun, listRuns, readEvents } from "../../runs/run.js";
-import { momentOf } from "../../services/moment.js";
+import { dateWindow } from "../../services/moment.js";
 import { listOf, snakeKeys } from "../envelope.js";
 const FIELDS = [
     "event",
@@ -35,7 +35,8 @@ const safeEvent = (event) => Object.fromEntries(FIELDS.flatMap((name) => {
 export const searchRuns = (dir, { query = "", status, errorCode, operation, profile, since, limit = 20, page = 1 } = {}) => {
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(page) || page < 1)
         throw new CliError("validation_error", "run search uses a limit from 1 to 100 and a positive page");
-    const from = since === undefined ? undefined : momentOf(since, "--since-time");
+    const window = dateWindow(since === undefined ? {} : { sinceTime: since });
+    const from = window.since;
     if (from !== undefined && !Number.isFinite(from))
         throw new CliError("validation_error", "--since-time must be a valid date or ISO timestamp");
     const needle = query.toLowerCase();
@@ -100,7 +101,13 @@ export const searchRuns = (dir, { query = "", status, errorCode, operation, prof
         if (matches.length > offset + limit)
             break;
     }
-    return { items: matches.slice(offset, offset + limit), page, limit, hasMore: matches.length > offset + limit };
+    return {
+        items: matches.slice(offset, offset + limit),
+        page,
+        limit,
+        hasMore: matches.length > offset + limit,
+        meta: window.meta,
+    };
 };
 /** A page of `searchRuns` in the list envelope; `args` are the search's own, so `page.next` reruns it. */
 export const runsFound = (found, args) => listOf("runs search", {
@@ -109,4 +116,5 @@ export const runsFound = (found, args) => listOf("runs search", {
     has_more: found.hasMore,
     page: found.page,
     args: Object.fromEntries(Object.entries(args).filter(([name, value]) => value !== undefined && name !== "page")),
+    meta: found.meta,
 });

package/dist/documents/blocks.d.ts

@@ -0,0 +1,45 @@
+export interface Inline {
+    text: string;
+    bold?: true;
+    italic?: true;
+    strike?: true;
+    code?: true;
+    link?: string;
+}
+export type ListKind = "bullet" | "number" | "check";
+export type Block = {
+    kind: "heading";
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    inlines: Inline[];
+} | {
+    kind: "paragraph";
+    inlines: Inline[];
+} | {
+    kind: "item";
+    list: ListKind;
+    depth: number;
+    checked?: boolean;
+    inlines: Inline[];
+} | {
+    kind: "code";
+    language?: string;
+    text: string;
+} | {
+    kind: "quote";
+    inlines: Inline[];
+} | {
+    kind: "table";
+    header: Inline[][];
+    rows: Inline[][][];
+} | {
+    kind: "image";
+    url: string;
+    alt: string;
+} | {
+    kind: "rule";
+};
+/** Adjacent runs with the same marks merge and empty runs drop, so two equal texts give one key. */
+export declare const normalizeInlines: (inlines: Inline[]) => Inline[];
+export declare const blockKey: (block: Block) => string;
+/** The same key with checklist ticks left out: two blocks that differ only in a tick share it. */
+export declare const blockShape: (block: Block) => string;

package/dist/documents/blocks.js

@@ -0,0 +1,48 @@
+const MARKS = ["bold", "italic", "strike", "code", "link"];
+const sameMarks = (a, b) => MARKS.every((mark) => a[mark] === b[mark]);
+/** Adjacent runs with the same marks merge and empty runs drop, so two equal texts give one key. */
+export const normalizeInlines = (inlines) => {
+    const out = [];
+    for (const inline of inlines) {
+        if (!inline.text)
+            continue;
+        const last = out.at(-1);
+        if (last && sameMarks(last, inline))
+            last.text += inline.text;
+        else
+            out.push({ ...inline });
+    }
+    return out;
+};
+const inlineKey = (inline) => [inline.text, ...MARKS.map((mark) => inline[mark] ?? "")];
+const key = (block, withChecked) => {
+    switch (block.kind) {
+        case "heading":
+            return [block.kind, block.level, normalizeInlines(block.inlines).map(inlineKey)];
+        case "paragraph":
+        case "quote":
+            return [block.kind, normalizeInlines(block.inlines).map(inlineKey)];
+        case "item":
+            return [
+                block.kind,
+                block.list,
+                block.depth,
+                withChecked && block.list === "check" ? Boolean(block.checked) : "",
+                normalizeInlines(block.inlines).map(inlineKey),
+            ];
+        case "code":
+            return [block.kind, block.language ?? "", block.text];
+        case "table":
+            return [
+                block.kind,
+                [block.header, ...block.rows].map((row) => row.map((cell) => normalizeInlines(cell).map(inlineKey))),
+            ];
+        case "image":
+            return [block.kind, block.url, block.alt];
+        case "rule":
+            return [block.kind];
+    }
+};
+export const blockKey = (block) => JSON.stringify(key(block, true));
+/** The same key with checklist ticks left out: two blocks that differ only in a tick share it. */
+export const blockShape = (block) => JSON.stringify(key(block, false));

package/dist/documents/index.d.ts

@@ -1,9 +1,14 @@
+export { type BlockHunk, diffBlocks, type Reconciled, reconcileBlocks } from "../services/documents/block-diff.js";
 export { type Complete, extractMemories } from "../services/documents/extraction.js";
 export { documentIngestion, type IngestionOptions } from "../services/documents/ingestion.js";
 export { type DocumentKnowledge, documentKnowledge } from "../services/documents/knowledge.js";
 export type { SyncOptions } from "../services/documents/ports.js";
 export { extractDocumentMemories, type ImportedSource, type ProposalOptions } from "../services/documents/proposals.js";
+export { type PushOptions, type PushResult, planPush, pushDocuments, scanLocal, } from "../services/documents/push.js";
 export { type SyncResult, syncDocuments } from "../services/documents/sync.js";
+export { type Block, blockKey, blockShape, type Inline, type ListKind, normalizeInlines } from "./blocks.js";
 export { catalogFiles } from "./catalog.js";
+export { markdownBlocks } from "./markdown-blocks.js";
 export type { DocumentSource, IndexedSource, PictureWriter, SourceChange, SourceContent, SourceFile, SourceIndex, SourceSkip, SourceState, SourceStatePort, SourceWalk, SourceWork, TabText, } from "./model.js";
+export type { DocumentTarget, LocalDocument, Prepared, PushEntry, Pushed, PushPlan, PushState, PushStatePort, } from "./push-model.js";
 export { within } from "./scope.js";

package/dist/documents/index.js

@@ -1,7 +1,11 @@
+export { diffBlocks, reconcileBlocks } from "../services/documents/block-diff.js";
 export { extractMemories } from "../services/documents/extraction.js";
 export { documentIngestion } from "../services/documents/ingestion.js";
 export { documentKnowledge } from "../services/documents/knowledge.js";
 export { extractDocumentMemories } from "../services/documents/proposals.js";
+export { planPush, pushDocuments, scanLocal, } from "../services/documents/push.js";
 export { syncDocuments } from "../services/documents/sync.js";
+export { blockKey, blockShape, normalizeInlines } from "./blocks.js";
 export { catalogFiles } from "./catalog.js";
+export { markdownBlocks } from "./markdown-blocks.js";
 export { within } from "./scope.js";

package/dist/documents/markdown-blocks.d.ts

@@ -0,0 +1,3 @@
+import { type Block } from "./blocks.js";
+/** Markdown (CommonMark + GFM tables, task lists and strikethrough) as the blocks a provider can write natively. */
+export declare const markdownBlocks: (markdown: string) => Promise<Block[]>;

package/dist/documents/markdown-blocks.js

@@ -0,0 +1,123 @@
+import { normalizeInlines } from "./blocks.js";
+// Loaded on first use: importing the documents entry point would otherwise cost every command about 50 ms.
+let parser;
+const loadParser = () => (parser ??= Promise.all([
+    import("mdast-util-from-markdown"),
+    import("mdast-util-gfm"),
+    import("micromark-extension-gfm"),
+]).then(([{ fromMarkdown }, { gfmFromMarkdown }, { gfm }]) => (markdown) => fromMarkdown(markdown, { extensions: [gfm()], mdastExtensions: [gfmFromMarkdown()] })));
+/** Markdown (CommonMark + GFM tables, task lists and strikethrough) as the blocks a provider can write natively. */
+export const markdownBlocks = async (markdown) => {
+    const tree = (await loadParser())(markdown);
+    const definitions = new Map();
+    const collect = (node) => {
+        if (node.type === "definition")
+            definitions.set(node.identifier, node);
+        if ("children" in node)
+            for (const child of node.children)
+                collect(child);
+    };
+    collect(tree);
+    const images = [];
+    const inlinesOf = (nodes, marks = {}) => nodes.flatMap((node) => {
+        switch (node.type) {
+            case "text":
+                return [{ ...marks, text: node.value.replace(/\n/g, " ") }];
+            case "inlineCode":
+                return [{ ...marks, code: true, text: node.value }];
+            case "strong":
+                return inlinesOf(node.children, { ...marks, bold: true });
+            case "emphasis":
+                return inlinesOf(node.children, { ...marks, italic: true });
+            case "delete":
+                return inlinesOf(node.children, { ...marks, strike: true });
+            case "link":
+                return inlinesOf(node.children, { ...marks, link: node.url });
+            case "linkReference": {
+                const url = definitions.get(node.identifier)?.url;
+                return inlinesOf(node.children, url ? { ...marks, link: url } : marks);
+            }
+            case "break":
+                return [{ ...marks, text: "\n" }];
+            case "image":
+                images.push({ kind: "image", url: node.url, alt: node.alt ?? "" });
+                return [];
+            case "imageReference": {
+                const url = definitions.get(node.identifier)?.url;
+                if (url)
+                    images.push({ kind: "image", url, alt: node.alt ?? "" });
+                return [];
+            }
+            case "html":
+                return [{ ...marks, text: node.value }];
+            default:
+                return "children" in node ? inlinesOf(node.children, marks) : [];
+        }
+    });
+    const trimmed = (inlines) => {
+        const out = normalizeInlines(inlines);
+        const first = out[0];
+        const last = out.at(-1);
+        if (first)
+            first.text = first.text.trimStart();
+        if (last)
+            last.text = last.text.trimEnd();
+        return normalizeInlines(out);
+    };
+    const withImages = (block) => {
+        const found = images.splice(0);
+        if (block?.kind === "paragraph" && !block.inlines.length)
+            return found;
+        return block ? [block, ...found] : found;
+    };
+    const textOf = (node) => node.children.flatMap((child) => child.type === "paragraph" || child.type === "heading" ? inlinesOf(child.children) : []);
+    const blocks = (nodes, depth = 0) => nodes.flatMap((node) => {
+        switch (node.type) {
+            case "heading":
+                return withImages({ kind: "heading", level: node.depth, inlines: trimmed(inlinesOf(node.children)) });
+            case "paragraph":
+                return withImages({ kind: "paragraph", inlines: trimmed(inlinesOf(node.children)) });
+            case "code":
+                return [{ kind: "code", ...(node.lang ? { language: node.lang } : {}), text: node.value }];
+            case "blockquote":
+                return node.children.flatMap((child) => child.type === "paragraph" || child.type === "heading"
+                    ? withImages({ kind: "quote", inlines: trimmed(inlinesOf(child.children)) })
+                    : blocks([child], depth));
+            case "thematicBreak":
+                return [{ kind: "rule" }];
+            case "table": {
+                const [head, ...rows] = node.children.map((row) => row.children.map((cell) => trimmed(inlinesOf(cell.children))));
+                return [{ kind: "table", header: head ?? [], rows }];
+            }
+            case "list":
+                return node.children.flatMap((item) => {
+                    const [first, ...rest] = item.children;
+                    const head = {
+                        kind: "item",
+                        list: (item.checked != null ? "check" : node.ordered ? "number" : "bullet"),
+                        depth,
+                        ...(item.checked != null ? { checked: item.checked } : {}),
+                        inlines: trimmed(first && first.type === "paragraph" ? inlinesOf(first.children) : []),
+                    };
+                    const tail = first && first.type !== "paragraph" ? [first, ...rest] : rest;
+                    return [
+                        ...withImages(head),
+                        ...tail.flatMap((child) => child.type === "list"
+                            ? blocks([child], depth + 1)
+                            : child.type === "paragraph"
+                                ? withImages({ kind: "paragraph", inlines: trimmed(inlinesOf(child.children)) })
+                                : blocks([child], depth)),
+                    ];
+                });
+            case "html":
+                return [{ kind: "paragraph", inlines: [{ text: node.value }] }];
+            case "definition":
+            case "footnoteDefinition":
+            case "yaml":
+                return [];
+            default:
+                return "children" in node ? withImages({ kind: "paragraph", inlines: trimmed(textOf(node)) }) : [];
+        }
+    });
+    return blocks(tree.children);
+};

package/dist/documents/push-model.d.ts

@@ -0,0 +1,89 @@
+/** A local file a push mirrors: its path relative to the mirrored folder, with `/` separators. */
+export interface LocalDocument {
+    path: string;
+    absolute: string;
+    hash: string;
+    kind: string;
+}
+export interface Pushed<S> {
+    id: string;
+    url: string;
+    /** What the provider reads back after its own write; the next push compares the remote against it. */
+    snapshot: S;
+}
+/**
+ * What an update found before writing. Only `write` reaches the remote, so a conflict or a file with nothing to
+ * change never counts as a write.
+ */
+export type Prepared<S> = {
+    conflict: string;
+} | {
+    missing: true;
+} | {
+    unchanged: Pushed<S>;
+} | {
+    write(): Promise<Pushed<S>>;
+};
+/**
+ * A provider that writes local files as its own native documents. Every write is one provider call per
+ * file (or one all-or-nothing batch): a write cut in half would read back as somebody else's edit.
+ */
+export interface DocumentTarget<S> {
+    identity(): Promise<string>;
+    /** The provider's document kind for a local path, or undefined when the path is not pushed. */
+    kindOf(path: string): string | undefined;
+    /** Finds the folder carrying `origin` or creates it: a crash between create and save must not duplicate it. */
+    ensureFolder(input: {
+        parent: string;
+        name: string;
+        origin: string;
+    }): Promise<string>;
+    findByOrigin(origin: string): Promise<Pushed<S> | undefined>;
+    create(input: {
+        file: LocalDocument;
+        name: string;
+        parent: string;
+        origin: string;
+        operationId: string;
+        signal?: AbortSignal;
+    }): Promise<Pushed<S>>;
+    /** Reads the remote and compares it with `recorded`; a conflict instead of a write unless `force`. */
+    prepare(input: {
+        id: string;
+        file: LocalDocument;
+        recorded: S;
+        force: boolean;
+        signal?: AbortSignal;
+    }): Promise<Prepared<S>>;
+}
+export interface PushEntry<S> {
+    id: string;
+    url: string;
+    kind: string;
+    hash: string;
+    snapshot: S;
+    pushedAt: string;
+}
+export interface PushState<S> {
+    version: 1;
+    principal: string;
+    root: string;
+    target: string;
+    folders: Record<string, string>;
+    entries: Record<string, PushEntry<S>>;
+    /** Saved before a create, so a crash after the provider wrote but before this state was saved finds the file. */
+    pending: Record<string, {
+        origin: string;
+        operationId: string;
+    }>;
+}
+export interface PushStatePort<S> {
+    read(): PushState<S>;
+    save(state: PushState<S>): void;
+}
+export interface PushPlan {
+    create: LocalDocument[];
+    update: LocalDocument[];
+    unchanged: LocalDocument[];
+    orphans: string[];
+}

package/dist/documents/push-model.js

@@ -0,0 +1 @@
+export {};

package/dist/documents.d.ts

@@ -1,3 +1,4 @@
+export { readSpreadsheet } from "./attachments/documents.js";
 export type { Engine, Extraction, FileHint, LoadEngine } from "./attachments/extract.js";
 export { extractText, importEngine, MAX_FILE_BYTES, MAX_TEXT_CHARS } from "./attachments/extract.js";
 export { attachmentMaxBytes } from "./attachments/limits.js";

package/dist/documents.js

@@ -1,3 +1,4 @@
+export { readSpreadsheet } from "./attachments/documents.js";
 export { extractText, importEngine, MAX_FILE_BYTES, MAX_TEXT_CHARS } from "./attachments/extract.js";
 export { attachmentMaxBytes } from "./attachments/limits.js";
 export { columnName, sheetText } from "./attachments/sheets.js";

package/dist/errors/reasons.js

@@ -26,6 +26,9 @@ const OTHERS = [
     validation("extraction.text-too-long", "the text is too long for memory extraction"),
     validation("file.locked", "another process holds the file's lock"),
     ["profile.wrong-account", "authentication_error", "the signed-in source account does not match this profile"],
+    validation("push.too-many-files", "the folder holds more files than one push takes"),
+    validation("push.unreadable", "the folder to push could not be read"),
+    validation("spreadsheet.unreadable", "the workbook could not be read"),
     validation("store.refused", "the local store refused the document text"),
     ["store.not-writable", "permission_error", "the message store cannot be written from this process"],
     validation("catalog.scope-limit", "the selected catalog exceeds its entry limit"),

package/dist/meetings/answers.d.ts

@@ -1,4 +1,4 @@
-import { type ItemEnvelope, type ListEnvelope } from "@wirecat/cli-base/standards";
+import { type ItemEnvelope, type ListEnvelope, type Meta } from "@wirecat/cli-base/standards";
 import * as v from "valibot";
 import { type MeetingOwner } from "./item.js";
 import type { Summary, Transcript, TranscriptRow } from "./model.js";
@@ -160,4 +160,6 @@ export declare const MEETING_STEPS: ({
 export declare const meetingHitItem: (hit: SearchHit & {
     ref: string;
 }) => MeetingHitItem;
-export declare const meetingHitsList: (found: MeetingSearchPage, limit: number, command?: string, args?: Record<string, unknown>) => MeetingListBody<MeetingHitItem>;
+export declare const meetingHitsList: (found: MeetingSearchPage, limit: number, command?: string, args?: Record<string, unknown>, meta?: Partial<Meta>) => MeetingListBody<MeetingHitItem> & {
+    meta?: Partial<Meta>;
+};

package/dist/meetings/answers.js

@@ -201,7 +201,7 @@ export const meetingHitItem = (hit) => ({
             },
         }),
 });
-export const meetingHitsList = (found, limit, command = "search meetings", args = {}) => {
+export const meetingHitsList = (found, limit, command = "search meetings", args = {}, meta = {}) => {
     const items = found.items.map(meetingHitItem);
     const cursor = found.hasMore && found.nextCursor !== null ? found.nextCursor : undefined;
     const pending = found.coverage.indexing === "pending";
@@ -238,5 +238,6 @@ export const meetingHitsList = (found, limit, command = "search meetings", args
                 ],
             }
             : {}),
+        ...(Object.keys(meta).length === 0 ? {} : { meta }),
     };
 };

package/dist/meetings/cli/index.d.ts

@@ -17,4 +17,4 @@ export declare const addMeetingCommands: (program: Command, deps: MeetingCommand
 export { addMeetingPassageCommand, createMeetingPassageCommand, type MeetingPassageFlags, meetingPassageRequest, } from "./passage.js";
 export { addMeetingProjectEvidenceCommand } from "./project-evidence.js";
 export { queryWordsAfterOptions } from "./query-options.js";
-export { addMeetingSearchCommand, createMeetingSearchCommand, type MeetingHitSearch, type MeetingHitSearchOptions, type MeetingSearchFlags, meetingHitSearchRequest, meetingSearchArguments, validateMeetingHitSearch, } from "./search.js";
+export { addMeetingSearchCommand, createMeetingSearchCommand, type MeetingHitSearch, type MeetingHitSearchOptions, type MeetingSearchFlags, meetingHitSearchRequest, meetingSearchArguments, meetingSearchMeta, validateMeetingHitSearch, } from "./search.js";

package/dist/meetings/cli/index.js

@@ -144,4 +144,4 @@ export const addMeetingCommands = (program, deps) => {
 export { addMeetingPassageCommand, createMeetingPassageCommand, meetingPassageRequest, } from "./passage.js";
 export { addMeetingProjectEvidenceCommand } from "./project-evidence.js";
 export { queryWordsAfterOptions } from "./query-options.js";
-export { addMeetingSearchCommand, createMeetingSearchCommand, meetingHitSearchRequest, meetingSearchArguments, validateMeetingHitSearch, } from "./search.js";
+export { addMeetingSearchCommand, createMeetingSearchCommand, meetingHitSearchRequest, meetingSearchArguments, meetingSearchMeta, validateMeetingHitSearch, } from "./search.js";

package/dist/meetings/cli/search.d.ts

@@ -1,3 +1,4 @@
+import type { Meta } from "@wirecat/cli-base/standards";
 import { Command } from "commander";
 import type { MeetingSearchPage } from "../search-store.js";
 import { type MeetingHitSearchOptions } from "../search-validation.js";
@@ -13,6 +14,8 @@ export interface MeetingSearchFlags {
     topic?: string;
     sinceTime?: number;
     untilTime?: number;
+    /** The zone a date or time without one was read in; the parser sets it, since the typed text is gone after. */
+    timesReadIn?: string;
     limit?: number;
     cursor?: string;
     maxReadBytes?: number;
@@ -23,6 +26,8 @@ export declare const createMeetingSearchCommand: (program: Command) => Command;
 export declare const meetingHitSearchRequest: (query: string, options: MeetingSearchFlags, signal?: AbortSignal) => MeetingHitSearchOptions;
 /** Parsed dates must become ISO values again so the CLI can replay its own continuation. */
 export declare const meetingSearchArguments: (query: string, options: MeetingSearchFlags) => Record<string, unknown>;
+/** What `meta` says about the dates: the zone one without its own was read in, and the window in UTC. */
+export declare const meetingSearchMeta: (options: MeetingSearchFlags) => Pick<Meta, "timezone" | "window">;
 export declare const addMeetingSearchCommand: (program: Command, deps: {
     search: (query: string, request: MeetingHitSearchOptions, options: MeetingSearchFlags & Record<string, unknown>) => Promise<MeetingSearchPage>;
     signal: () => AbortSignal | undefined;

package/dist/meetings/cli/search.js

@@ -5,13 +5,19 @@ import { Command } from "commander";
 import { meetingHitsList } from "../answers.js";
 import { validateMeetingHitSearch } from "../search-validation.js";
 export { validateMeetingHitSearch } from "../search-validation.js";
-const moment = (flag, end) => (value) => {
+const ZONED = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+const moment = (flag, end, readIn) => (value) => {
+    const zone = timezoneOf();
+    let time;
     try {
-        return zonedMoment(value, timezoneOf(), { start: 0, end: value.length }, { end });
+        time = zonedMoment(value, zone, { start: 0, end: value.length }, { end });
     }
     catch {
         throw new CliError("validation_error", `${flag} takes an ISO date, or a time with or without an offset`);
     }
+    if (!ZONED.test(value.trim()))
+        readIn(zone);
+    return time;
 };
 const integer = (value) => {
     if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
@@ -25,6 +31,7 @@ export const createMeetingSearchCommand = (program) => {
         search = new Command("search").description("search the stored resources");
         program.addCommand(search);
     }
+    const readIn = (zone) => command.setOptionValue("timesReadIn", zone);
     const command = search
         .command("meetings")
         .description("find words in stored meetings, indexing new ones first")
@@ -37,8 +44,8 @@ export const createMeetingSearchCommand = (program) => {
         .option("--project <name>", "meetings confirmed in this project, by name, key or alias")
         .option("--tag <name>", "meetings with this tag, by name or alias")
         .option("--topic <name>", "meetings with this topic, by name or alias")
-        .option("--since-time <time>", "meetings starting at or after this ISO 8601 date or time", moment("--since-time", false))
-        .option("--until-time <time>", "meetings starting at or before this ISO 8601 date or time; a date alone covers that whole local day", moment("--until-time", true))
+        .option("--since-time <time>", "meetings starting at or after this ISO 8601 date or time", moment("--since-time", false, readIn))
+        .option("--until-time <time>", "meetings starting at or before this ISO 8601 date or time; a date alone covers that whole local day", moment("--until-time", true, readIn))
         .option("--limit <n>", "how many hits, 1 through 1000 (default 100)", integer)
         .option("--cursor <cursor>", "continue from the previous page's page.next_cursor, with the same query and filters")
         .option("--max-read-bytes <bytes>", "most stored bytes to read, 1 through 67108864 (default 4194304)", integer);
@@ -86,7 +93,18 @@ export const meetingSearchArguments = (query, options) => Object.fromEntries(Obj
     until_time: options.untilTime === undefined ? undefined : new Date(options.untilTime).toISOString(),
     max_read_bytes: options.maxReadBytes ?? 4194304,
 }).filter(([, value]) => value !== undefined));
+/** What `meta` says about the dates: the zone one without its own was read in, and the window in UTC. */
+export const meetingSearchMeta = (options) => {
+    const window = {
+        ...(options.sinceTime === undefined ? {} : { since: new Date(options.sinceTime).toISOString() }),
+        ...(options.untilTime === undefined ? {} : { until: new Date(options.untilTime).toISOString() }),
+    };
+    return {
+        ...(options.timesReadIn === undefined ? {} : { timezone: options.timesReadIn }),
+        ...(Object.keys(window).length === 0 ? {} : { window }),
+    };
+};
 export const addMeetingSearchCommand = (program, deps) => createMeetingSearchCommand(program).action(async (query, options) => {
     const request = meetingHitSearchRequest(query, options, deps.signal());
-    deps.output(meetingHitsList(await deps.search(query, request, options), request.limit ?? 100, "search meetings", meetingSearchArguments(query, options)));
+    deps.output(meetingHitsList(await deps.search(query, request, options), request.limit ?? 100, "search meetings", meetingSearchArguments(query, options), meetingSearchMeta(options)));
 });

package/dist/meetings/mcp/search.d.ts

@@ -150,7 +150,9 @@ export declare const callMeetingSearchTool: (search: MeetingHitSearch, input: un
             started_at: string | null;
             url: string | null;
         } | undefined;
-    }>;
+    }> & {
+        meta?: Partial<import("@wirecat/cli-base/standards").Meta>;
+    };
 } & {
     isError?: boolean;
 })>;

package/dist/meetings/mcp/search.js

@@ -60,10 +60,11 @@ export const callMeetingSearchTool = async (search, input, signal, failure = {})
         const query = args.query;
         validateMeetingHitSearch(query, options);
         signal?.throwIfAborted();
-        const result = meetingHitsList(await search(query, options), options.limit ?? 100, "search meetings", {
-            ...args,
-            max_read_bytes: options.maxReadBytes ?? 4194304,
-        });
+        const window = {
+            ...(options.since === undefined ? {} : { since: new Date(options.since).toISOString() }),
+            ...(options.until === undefined ? {} : { until: new Date(options.until).toISOString() }),
+        };
+        const result = meetingHitsList(await search(query, options), options.limit ?? 100, "search meetings", { ...args, max_read_bytes: options.maxReadBytes ?? 4194304 }, Object.keys(window).length === 0 ? {} : { window });
         signal?.throwIfAborted();
         return agentResult({
             content: [{ type: "text", text: JSON.stringify(result) }],