@eightstate/escli 0.5.0 → 0.7.1

package/dist/commands/notion/page/move.js

@@ -0,0 +1,59 @@
+import { Args, Flags } from '@oclif/core';
+import { notionPagesMove } from '../../../services/notion.js';
+import { botName, exactOneDestination, formatParent, notionErrors, NotionWriteCommand, pageRef, parentRef, parseNotionId, recordValue, renderReceipt, requireYes, } from '../../../lib/notion/trash-move/support.js';
+export default class NotionPageMove extends NotionWriteCommand {
+    static errors = notionErrors();
+    static summary = 'Move a Notion page to a new parent page or data source';
+    static description = 'Move a page under another page or into a database data source. Use --to-data-source with a data_source_id, not a database_id.';
+    static examples = [
+        '<%= config.bin %> notion page move 195de922-1179-449f-ab80-75a27c979105 --to-page 0f6b6d9e-36d4-49ff-a4dc-037b65fd08c2 --yes',
+        '<%= config.bin %> notion page move 195de922-1179-449f-ab80-75a27c979105 --to-data-source 1c7b35e6-e67f-8096-bf3f-000ba938459e --yes',
+    ];
+    static aliases = [];
+    static flags = {
+        'to-page': Flags.string({ description: 'Destination parent page ID or URL.' }),
+        'to-data-source': Flags.string({ description: 'Destination database data source ID.' }),
+        yes: Flags.boolean({ description: 'Confirm the workflow-changing write without prompting.', default: false }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        page: Args.string({ description: 'Page ID or Notion URL.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionPageMove);
+        this.outputFlags = flags;
+        requireYes(flags.yes);
+        const pageId = parseNotionId(args.page);
+        const to = exactOneDestination(flags['to-page'], flags['to-data-source']);
+        const result = await notionPagesMove(pageId, to);
+        const raw = this.rememberResult(result);
+        const rawRecord = recordValue(raw);
+        const returnedParent = parentRef(rawRecord?.parent);
+        const bot = botName(raw);
+        return {
+            action: 'page.move',
+            page: pageRef(raw, pageId),
+            from: parentRef(rawRecord?.previous_parent ?? rawRecord?.from) ?? { type: 'unknown' },
+            to: { ...to, ...returnedParent },
+            destructive: false,
+            workflow_risk: 'Page location changed; database properties may now govern this page.',
+            ...(bot ? { bot } : {}),
+            notion_version: '2026-03-11',
+        };
+    }
+    render(data) {
+        return renderReceipt([
+            ['action', data.action],
+            ['page', `${data.page.title} (${data.page.id})`],
+            ['from', formatParent(data.from)],
+            ['to', formatParent(data.to)],
+            ['destructive', false],
+            ['workflow_risk', 'page location changed; database properties may now govern this page'],
+            ['bot', data.bot ?? ''],
+            ['notion_version', data.notion_version],
+        ]);
+    }
+}
+//# sourceMappingURL=move.js.map

package/dist/commands/notion/page/read.js

@@ -0,0 +1,60 @@
+import { Args, Flags } from '@oclif/core';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { writeStdout } from '../../../io/io.js';
+import { notionFetchPage } from '../../../services/notion.js';
+import { PAGE_CONTENT_ERROR_CODES, PageContentReadDataSchema, PageRefArg, emitRaw, normalizeMarkdownBody, pageIdFromRef, previewMarkdown, renderRead, withoutRaw, RawBypassCommand, } from '../../../lib/notion/page/content-common.js';
+export { PageContentReadDataSchema };
+export default class NotionPageRead extends RawBypassCommand {
+    static errors = [...PAGE_CONTENT_ERROR_CODES, ErrorCode.UsageUnknownFlag];
+    static summary = 'Read page body markdown';
+    static description = 'Read a Notion page body as native enhanced markdown with a compact metadata trailer.';
+    static examples = [
+        '<%= config.bin %> notion page read 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc',
+        '<%= config.bin %> notion page read https://notion.so/Q2-Planning-362e1f4a7d8c81b09f6ef2c9a7b630dc --raw',
+        '<%= config.bin %> --json notion page read 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc',
+    ];
+    static aliases = [];
+    static flags = {
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        page: Args.string(PageRefArg),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionPageRead);
+        const pageId = pageIdFromRef(args.page);
+        const result = await notionFetchPage(pageId);
+        if (flags.raw) {
+            await emitRaw(result.raw);
+            this.humanOutputHandled = true;
+            return {
+                surface: 'page-content',
+                command: 'read',
+                page: { id: pageId },
+                content: { format: 'notion-enhanced-markdown', chars_total: 0, preview: '', notion_truncated: false, unknown_block_ids: [] },
+                raw: result.raw,
+            };
+        }
+        const body = normalizeMarkdownBody(result, pageId);
+        const data = {
+            surface: 'page-content',
+            command: 'read',
+            page: { id: body.id, title: body.title, url: body.url },
+            content: {
+                format: 'notion-enhanced-markdown',
+                chars_total: body.markdown.length,
+                preview: previewMarkdown(body.markdown),
+                notion_truncated: body.truncated,
+                unknown_block_ids: body.unknown_block_ids,
+            },
+        };
+        if (flags.json)
+            return withoutRaw(data);
+        await writeStdout(`${renderRead(data)}\n`);
+        this.humanOutputHandled = true;
+        return data;
+    }
+}
+//# sourceMappingURL=read.js.map

package/dist/commands/notion/page/replace-content.js

@@ -0,0 +1,80 @@
+import { Args, Flags } from '@oclif/core';
+import { notionPagePatchMarkdown } from '../../../services/notion.js';
+import { boolValue, deltaEstimate, estimateText, formatEstimate, markdownPreview, notionErrors, NotionWriteCommand, pageRef, parseNotionId, readMarkdownInput, recordValue, renderReceipt, requireYes, stringValue, unknownBlockIds, } from '../../../lib/notion/trash-move/support.js';
+export default class NotionPageReplaceContent extends NotionWriteCommand {
+    static errors = notionErrors();
+    static summary = 'Replace a Notion page body with markdown';
+    static description = 'Replace page markdown with Notion replace_content. If child pages/databases would be deleted, re-run with --allow-deleting-content after review.';
+    static examples = [
+        '<%= config.bin %> notion page replace-content 195de922-1179-449f-ab80-75a27c979105 --file replacement.md --yes',
+        '<%= config.bin %> notion page replace-content 195de922-1179-449f-ab80-75a27c979105 --text "# Replacement" --allow-deleting-content --yes',
+    ];
+    static aliases = [];
+    static flags = {
+        file: Flags.string({ description: 'Markdown file to use as the new page body.' }),
+        text: Flags.string({ description: 'Markdown text to use as the new page body.' }),
+        'allow-deleting-content': Flags.boolean({ description: 'Allow deletion of child pages/databases if Notion requires it.', default: false }),
+        yes: Flags.boolean({ description: 'Confirm the destructive write without prompting.', default: false }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        page: Args.string({ description: 'Page ID or Notion URL.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionPageReplaceContent);
+        this.outputFlags = flags;
+        requireYes(flags.yes);
+        const pageId = parseNotionId(args.page);
+        const input = await readMarkdownInput(flags.file, flags.text);
+        // Canonical replace_content body — matches notion page replace and the
+        // page-content test contract. allow_deleting_content stays top-level and
+        // is only emitted when true.
+        const body = {
+            type: 'replace_content',
+            replace_content: { markdown: input.markdown },
+            ...(flags['allow-deleting-content'] ? { allow_deleting_content: true } : {}),
+        };
+        const result = await notionPagePatchMarkdown(pageId, body);
+        const raw = this.rememberResult(result);
+        const rawRecord = recordValue(raw);
+        const markdown = stringValue(rawRecord?.markdown) ?? '';
+        const before = estimateText(stringValue(rawRecord?.before_markdown) ?? stringValue(rawRecord?.previous_markdown) ?? '');
+        const after = estimateText(input.markdown);
+        const delta = deltaEstimate(before, after);
+        const truncated = boolValue(rawRecord?.truncated) ?? false;
+        return {
+            action: 'page.replace-content',
+            page: pageRef(raw, pageId),
+            edit: {
+                mode: 'replace_content',
+                source: input.source,
+                allow_deleting_content: flags['allow-deleting-content'],
+                before_estimate: before,
+                after_estimate: after,
+                delta,
+            },
+            result: { markdown_preview: markdownPreview(markdown), truncated, unknown_block_ids: unknownBlockIds(raw) },
+            ...(flags['allow-deleting-content'] ? { warning: 'Full body replacement completed with allow_deleting_content=true. Review in Notion.' } : {}),
+            notion_version: '2026-03-11',
+        };
+    }
+    render(data) {
+        return renderReceipt([
+            ['action', data.action],
+            ['page', `${data.page.title} (${data.page.id})`],
+            ['mode', data.edit.mode],
+            ['source', data.edit.source],
+            ['allow_deleting_content', data.edit.allow_deleting_content],
+            ['before_estimate', formatEstimate(data.edit.before_estimate)],
+            ['after_estimate', formatEstimate(data.edit.after_estimate)],
+            ['delta', formatEstimate(data.edit.delta)],
+            ['markdown_preview', `\n${data.result.markdown_preview}`],
+            ['truncated', data.result.truncated],
+            ['unknown_block_ids', data.result.unknown_block_ids],
+            ...(data.warning ? [['warning', data.warning.toLowerCase()]] : []),
+        ]);
+    }
+}
+//# sourceMappingURL=replace-content.js.map

package/dist/commands/notion/page/replace-text.js

@@ -0,0 +1,80 @@
+import { Args, Flags } from '@oclif/core';
+import { notionPagePatchMarkdown } from '../../../services/notion.js';
+import { boolValue, markdownPreview, notionErrors, NotionWriteCommand, numberValue, pageRef, parseNotionId, recordValue, renderReceipt, requireYes, stringValue, unknownBlockIds, } from '../../../lib/notion/trash-move/support.js';
+export default class NotionPageReplaceText extends NotionWriteCommand {
+    static errors = notionErrors();
+    static summary = 'Search and replace exact markdown in a Notion page';
+    static description = 'Patch page markdown with Notion update_content. --allow-deleting-content is only sent when explicitly supplied.';
+    static examples = [
+        '<%= config.bin %> notion page replace-text 195de922-1179-449f-ab80-75a27c979105 --old "draft" --new "final" --yes',
+        '<%= config.bin %> notion page replace-text 195de922-1179-449f-ab80-75a27c979105 --old "old" --new "new" --replace-all --yes',
+    ];
+    static aliases = [];
+    static flags = {
+        old: Flags.string({ description: 'Exact markdown to replace.', required: true }),
+        new: Flags.string({ description: 'Replacement markdown.', required: true }),
+        'replace-all': Flags.boolean({ description: 'Replace all exact matches.', default: false }),
+        'allow-deleting-content': Flags.boolean({ description: 'Allow deletion of child pages/databases if Notion requires it.', default: false }),
+        yes: Flags.boolean({ description: 'Confirm the write without prompting.', default: false }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        page: Args.string({ description: 'Page ID or Notion URL.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionPageReplaceText);
+        this.outputFlags = flags;
+        requireYes(flags.yes);
+        const pageId = parseNotionId(args.page);
+        // Canonical update_content body — matches notion page edit and the
+        // page-content test contract. allow_deleting_content stays top-level and
+        // is only emitted when true; never nested inside update_content.
+        const body = {
+            type: 'update_content',
+            update_content: {
+                content_updates: [{ old_str: flags.old, new_str: flags.new, replace_all_matches: flags['replace-all'] }],
+            },
+            ...(flags['allow-deleting-content'] ? { allow_deleting_content: true } : {}),
+        };
+        const result = await notionPagePatchMarkdown(pageId, body);
+        const raw = this.rememberResult(result);
+        const rawRecord = recordValue(raw);
+        const markdown = stringValue(rawRecord?.markdown) ?? '';
+        const replaced = numberValue(rawRecord?.matches_replaced) ?? numberValue(recordValue(rawRecord?.edit)?.matches_replaced) ?? (flags['replace-all'] ? 0 : 1);
+        const truncated = boolValue(rawRecord?.truncated) ?? false;
+        return {
+            action: 'page.replace-text',
+            page: pageRef(raw, pageId),
+            edit: {
+                mode: 'update_content',
+                matches_replaced: replaced,
+                replace_all_matches: flags['replace-all'],
+                allow_deleting_content: flags['allow-deleting-content'],
+                old_preview: markdownPreview(flags.old),
+                new_preview: markdownPreview(flags.new),
+            },
+            result: { markdown_preview: markdownPreview(markdown), truncated, unknown_block_ids: unknownBlockIds(raw) },
+            ...(flags.new.length < flags.old.length ? { warning: 'Content text was removed. Child page/database deletion was not allowed.' } : {}),
+            notion_version: '2026-03-11',
+        };
+    }
+    render(data) {
+        return renderReceipt([
+            ['action', data.action],
+            ['page', `${data.page.title} (${data.page.id})`],
+            ['mode', data.edit.mode],
+            ['matches_replaced', data.edit.matches_replaced],
+            ['replace_all_matches', data.edit.replace_all_matches],
+            ['allow_deleting_content', data.edit.allow_deleting_content],
+            ['old_preview', data.edit.old_preview],
+            ['new_preview', data.edit.new_preview],
+            ['markdown_preview', `\n${data.result.markdown_preview}`],
+            ['truncated', data.result.truncated],
+            ['unknown_block_ids', data.result.unknown_block_ids],
+            ...(data.warning ? [['warning', data.warning.toLowerCase()]] : []),
+        ]);
+    }
+}
+//# sourceMappingURL=replace-text.js.map

package/dist/commands/notion/page/replace.js

@@ -0,0 +1,63 @@
+import { Args, Flags } from '@oclif/core';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { writeStdout } from '../../../io/io.js';
+import { notionPagePatchMarkdown } from '../../../services/notion.js';
+import { PAGE_CONTENT_ERROR_CODES, PageContentReplaceDataSchema, PageRefArg, buildReplaceBody, emitRaw, extractPageInfo, pageIdFromRef, previewMarkdown, readMarkdownSource, renderReplace, withoutRaw, RawBypassCommand, } from '../../../lib/notion/page/content-common.js';
+export { PageContentReplaceDataSchema };
+export default class NotionPageReplace extends RawBypassCommand {
+    static errors = [...PAGE_CONTENT_ERROR_CODES, ErrorCode.UsageUnknownFlag];
+    static summary = 'Replace page body markdown';
+    static description = 'Replace a Notion page body through Notion replace_content using native enhanced markdown.';
+    static examples = [
+        '<%= config.bin %> notion page replace 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc --file q2-planning-replacement.md',
+        '<%= config.bin %> notion page replace 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc --markdown "# Q2 Planning"',
+        '<%= config.bin %> notion page replace 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc --stdin --raw',
+    ];
+    static aliases = [];
+    static flags = {
+        markdown: Flags.string({ description: 'Enhanced markdown content.' }),
+        file: Flags.string({ description: 'Read enhanced markdown content from a file.' }),
+        stdin: Flags.boolean({ description: 'Read enhanced markdown content from stdin.', default: false }),
+        'allow-deleting-content': Flags.boolean({ description: 'Allow deletion of nested child pages/databases if Notion detects it.', default: false }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        page: Args.string(PageRefArg),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionPageReplace);
+        const pageId = pageIdFromRef(args.page);
+        const markdown = await readMarkdownSource(flags);
+        const result = await notionPagePatchMarkdown(pageId, buildReplaceBody(markdown, flags['allow-deleting-content']));
+        if (flags.raw) {
+            await emitRaw(result.raw);
+            this.humanOutputHandled = true;
+            return {
+                surface: 'page-content',
+                command: 'replace',
+                page: { id: pageId },
+                status: 'changed',
+                allow_deleting_content: flags['allow-deleting-content'],
+                submitted: { format: 'notion-enhanced-markdown', chars: markdown.length, preview: previewMarkdown(markdown, 20, 1200) },
+                raw: result.raw,
+            };
+        }
+        const page = extractPageInfo(result.data, pageId);
+        const data = {
+            surface: 'page-content',
+            command: 'replace',
+            page,
+            status: 'changed',
+            allow_deleting_content: flags['allow-deleting-content'],
+            submitted: { format: 'notion-enhanced-markdown', chars: markdown.length, preview: previewMarkdown(markdown, 20, 1200) },
+        };
+        if (flags.json)
+            return withoutRaw(data);
+        await writeStdout(`${renderReplace(data)}\n`);
+        this.humanOutputHandled = true;
+        return data;
+    }
+}
+//# sourceMappingURL=replace.js.map

package/dist/commands/notion/page/trash.js

@@ -0,0 +1,79 @@
+import { Args, Flags } from '@oclif/core';
+import { notionPagesTrash } from '../../../services/notion.js';
+import { botName, formatParentCompact, notionErrors, NotionWriteCommand, pageRef, parentRef, parseNotionId, renderReceipt, requireYes, } from '../../../lib/notion/trash-move/support.js';
+export default class NotionPageTrash extends NotionWriteCommand {
+    static errors = notionErrors();
+    static summary = 'Move a Notion page to Trash, or restore it with --restore';
+    static description = 'Soft-trash or restore a Notion page through the enrolled Notion bot. Requires --yes in non-interactive mode.';
+    static examples = [
+        '<%= config.bin %> notion page trash 195de922-1179-449f-ab80-75a27c979105 --yes',
+        '<%= config.bin %> notion page trash 195de922-1179-449f-ab80-75a27c979105 --restore --yes',
+        '<%= config.bin %> notion page trash https://www.notion.so/Old-launch-notes-195de9221179449fab8075a27c979105 --raw --yes',
+    ];
+    static aliases = [];
+    static flags = {
+        restore: Flags.boolean({ description: 'Restore the page instead of trashing it.', default: false }),
+        yes: Flags.boolean({ description: 'Confirm the destructive write without prompting.', default: false }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        page: Args.string({ description: 'Page ID or Notion URL.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionPageTrash);
+        this.outputFlags = flags;
+        requireYes(flags.yes);
+        const pageId = parseNotionId(args.page);
+        const result = await notionPagesTrash(pageId, !flags.restore);
+        const raw = this.rememberResult(result);
+        const page = pageRef(raw, pageId);
+        const bot = botName(raw);
+        if (flags.restore) {
+            return {
+                action: 'page.restore',
+                page,
+                state: { before: 'in_trash', after: 'active' },
+                restored_to: parentRef(result.data && typeof result.data === 'object' ? result.data.parent : undefined),
+                next: 'Verify the restored page appears in the expected parent.',
+                ...(bot ? { bot } : {}),
+                notion_version: '2026-03-11',
+            };
+        }
+        return {
+            action: 'page.trash',
+            page,
+            state: { before: 'active', after: 'in_trash' },
+            destructive: true,
+            reversible: true,
+            undo: `escli notion page trash ${page.id} --restore --yes`,
+            ...(bot ? { bot } : {}),
+            notion_version: '2026-03-11',
+        };
+    }
+    render(data) {
+        if (data.action === 'page.restore') {
+            return renderReceipt([
+                ['action', data.action],
+                ['page', `${data.page.title} (${data.page.id})`],
+                ['state', `${data.state.before} → ${data.state.after}`],
+                ['restored_to', formatParentCompact(data.restored_to)],
+                ['next', 'verify the page appears in the expected parent'],
+                ['bot', data.bot ?? ''],
+                ['notion_version', data.notion_version],
+            ]);
+        }
+        return renderReceipt([
+            ['action', data.action],
+            ['page', `${data.page.title} (${data.page.id})`],
+            ['state', `${data.state.before} → ${data.state.after}`],
+            ['destructive', true],
+            ['reversible', true],
+            ['undo', data.undo ?? ''],
+            ['bot', data.bot ?? ''],
+            ['notion_version', data.notion_version],
+        ]);
+    }
+}
+//# sourceMappingURL=trash.js.map

package/dist/commands/notion/search.js

@@ -0,0 +1,207 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { BaseCommand } from '../../base-command.js';
+import { renderTable } from '../../io/render-table.js';
+import { renderTrailer } from '../../io/render-trailer.js';
+import { writeStdout, writeStderr } from '../../io/io.js';
+import { NOTION_VERSION, notionSearch } from '../../services/notion.js';
+export const NotionSearchResultSchema = z.object({
+    rank: z.number().int().positive(),
+    kind: z.enum(['page', 'data_source']),
+    id: z.string(),
+    title: z.string().optional(),
+    name: z.string().optional(),
+    context: z.string(),
+    last_edited: z.string(),
+    match: z.string(),
+    next: z.string(),
+});
+export const NotionSearchDataSchema = z.object({
+    query: z.string(),
+    scope: z.literal('bot-visible'),
+    trash: z.enum(['hidden', 'included']),
+    results: z.array(NotionSearchResultSchema),
+    warnings: z.array(z.string()),
+    next: z.string().nullable(),
+    notion_version: z.literal(NOTION_VERSION),
+});
+let cachedVisibleScopes;
+export default class NotionSearch extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.UsageInvalid, ErrorCode.AuthRequired, ErrorCode.GateInvalidResponse, ErrorCode.ApiError, ErrorCode.NotionUnauthorized, ErrorCode.NotionRestricted, ErrorCode.NotionNotFound, ErrorCode.NotionRateLimited, ErrorCode.NotionValidation, ErrorCode.NotionConflict, ErrorCode.NotionTimeoutUncertain, ErrorCode.NotionEnrollmentRequired, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable];
+    static summary = 'Find bot-visible Notion page/data-source targets';
+    static description = 'Search Notion pages and data sources visible to the enrolled bot.';
+    static examples = ['<%= config.bin %> notion search roadmap', '<%= config.bin %> notion search "roadmap" --next 10d7e4d2-9a41-4c73-9d2d-4d3d860d5a91', '<%= config.bin %> notion search "roadmap" --raw'];
+    static aliases = ['notion s'];
+    static flags = {
+        next: Flags.string({ description: "Continue the same search using Notion's opaque pagination token." }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+        'include-trash': Flags.boolean({ description: 'Include results where Notion reports in_trash=true.', default: false }),
+    };
+    static args = {
+        query: Args.string({ description: 'Search query.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionSearch);
+        const response = await notionSearch(args.query, defined({ start_cursor: flags.next, include_trash: flags['include-trash'] || undefined }));
+        if (flags.raw) {
+            await writeStdout(`${JSON.stringify(response.raw)}\n`);
+            this.humanOutputHandled = true;
+            return response.raw;
+        }
+        const data = shapeSearchData(args.query, response.data, response.meta.next, flags.next, flags['include-trash']);
+        if (!flags.json) {
+            await writeStdout(`${renderNotionSearch(data, flags.next)}\n`);
+            this.humanOutputHandled = true;
+            if (data.results.length === 0 && !flags.quiet)
+                await writeZeroResultHint(args.query);
+        }
+        return data;
+    }
+}
+export function renderNotionSearch(data, nextToken) {
+    const lines = [`notion.search query=${data.query} scope=${data.scope} trash=${data.trash}${nextToken ? ` next=${nextToken}` : ''}`];
+    lines.push(renderTable({
+        header: ['#', 'kind', 'title/name', 'id', 'context', 'edited', 'match', 'next'],
+        rows: data.results.map((result) => [result.rank, result.kind, result.title ?? result.name ?? '', result.id, result.context, result.last_edited, result.match, actionLabel(result)]),
+    }));
+    if (data.results.length === 0)
+        lines.push('0 results.');
+    const trailer = renderTrailer({ next: data.next });
+    if (trailer)
+        lines.push(trailer);
+    const incompleteWarning = data.warnings.find((warning) => warning.startsWith('Notion says this search is incomplete:'));
+    if (incompleteWarning)
+        lines.push(`warning: ${incompleteWarning}`);
+    return lines.join('\n');
+}
+function shapeSearchData(query, body, metaNext, nextToken, includeTrash) {
+    const response = recordValue(body);
+    const results = (Array.isArray(response?.results) ? response.results : [])
+        .filter((result) => includeTrash || recordValue(result)?.in_trash !== true)
+        .map((result, index) => shapeResult(result, index, nextToken))
+        .filter((result) => result !== undefined);
+    const warnings = ['Search is bot-visible and not exhaustive workspace RAG.'];
+    if (response?.request_status?.type === 'incomplete') {
+        const reason = stringValue(response.request_status.incomplete_reason) ?? 'unknown';
+        warnings.push(`Notion says this search is incomplete: ${reason}. Narrow the query; do not treat this as exhaustive.`);
+    }
+    return {
+        query,
+        scope: 'bot-visible',
+        trash: includeTrash ? 'included' : 'hidden',
+        results,
+        warnings,
+        next: metaNext ?? stringValue(response?.next_cursor) ?? null,
+        notion_version: NOTION_VERSION,
+    };
+}
+function shapeResult(value, index, nextToken) {
+    const result = recordValue(value);
+    const id = stringValue(result?.id);
+    const object = stringValue(result?.object);
+    if (!result || !id || (object !== 'page' && object !== 'data_source'))
+        return undefined;
+    const title = titleForResult(result, object);
+    const kind = object;
+    return {
+        rank: index + 1 + (nextToken ? 0 : 0),
+        kind,
+        id,
+        ...(kind === 'page' ? { title } : { name: title }),
+        context: contextForResult(result),
+        last_edited: editedForResult(result),
+        match: matchForResult(title),
+        next: kind === 'page' ? `escli notion fetch ${id}` : `escli notion ds query ${id}`,
+    };
+}
+function titleForResult(result, object) {
+    if (object === 'data_source')
+        return plainText(result.title) || 'Untitled';
+    const properties = recordValue(result.properties);
+    const titleProperty = Object.values(properties ?? {}).find((property) => recordValue(property)?.type === 'title');
+    return plainText(recordValue(titleProperty)?.title) || plainText(result.title) || 'Untitled';
+}
+function contextForResult(result) {
+    const object = stringValue(result.object);
+    if (object === 'data_source') {
+        const parent = recordValue(result.database_parent);
+        const parentId = stringValue(parent?.database_id);
+        const props = Object.keys(recordValue(result.properties) ?? {}).filter((name) => name !== 'Name').slice(0, 4);
+        const propCount = Object.keys(recordValue(result.properties) ?? {}).filter((name) => name !== 'Name').length;
+        const propsSuffix = props.length > 0 ? `; props: ${props.join(', ')}${propCount > props.length ? ` +${propCount - props.length}` : ''}` : '';
+        return `db: ${parentId ?? 'unknown'}${propsSuffix}`;
+    }
+    const parent = recordValue(result.parent);
+    if (!parent)
+        return 'parent: unknown';
+    const type = stringValue(parent.type);
+    const id = type ? stringValue(parent[type]) : undefined;
+    if (type === 'workspace')
+        return 'parent: workspace';
+    if (type === 'page_id')
+        return `parent: ${id ?? 'unknown'}`;
+    if (type === 'database_id')
+        return `db: ${id ?? 'unknown'}`;
+    if (type === 'data_source_id')
+        return `data_source: ${id ?? 'unknown'}`;
+    return `parent: ${id ?? 'unknown'}`;
+}
+function editedForResult(result) {
+    const edited = stringValue(result.last_edited_time);
+    const editedBy = recordValue(result.last_edited_by);
+    const name = stringValue(editedBy?.name) ?? stringValue(editedBy?.id);
+    const timestamp = edited ? formatEditedTime(edited) : 'unknown';
+    return name ? `${timestamp} by ${name}` : timestamp;
+}
+function formatEditedTime(value) {
+    return value.replace(/:\d\d\.\d{3}Z$/u, 'Z');
+}
+function matchForResult(title) {
+    return title === 'Untitled' ? 'metadata match' : 'title/name match';
+}
+function actionLabel(result) {
+    return result.kind === 'page' ? `fetch ${result.id}` : `ds query ${result.id}`;
+}
+async function writeZeroResultHint(query) {
+    const scopes = await visibleScopes();
+    if (scopes.length === 0)
+        return;
+    await writeStderr(`no matches for "${query}" — bot can see: ${scopes.join(', ')}. Try one of these terms or share the target with the Notion bot.\n`);
+}
+async function visibleScopes() {
+    if (cachedVisibleScopes)
+        return cachedVisibleScopes;
+    const response = await notionSearch('', { page_size: 5 });
+    const root = recordValue(response.data);
+    const results = Array.isArray(root?.results) ? root.results : [];
+    cachedVisibleScopes = results.map((result) => titleForScope(result)).filter((name) => Boolean(name)).slice(0, 5);
+    return cachedVisibleScopes;
+}
+function titleForScope(value) {
+    const result = recordValue(value);
+    if (!result || result.in_trash === true)
+        return undefined;
+    const object = stringValue(result.object);
+    const title = titleForResult(result, object ?? '');
+    return title === 'Untitled' ? undefined : title;
+}
+function plainText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value.map((part) => stringValue(recordValue(part)?.plain_text) ?? stringValue(recordValue(recordValue(part)?.text)?.content) ?? '').join('').trim();
+}
+function defined(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+//# sourceMappingURL=search.js.map