@eightstate/escli 0.5.0 → 0.7.0

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

@@ -0,0 +1,71 @@
+import { Args, Flags } from '@oclif/core';
+import { notionBlocksDelete, notionBlocksUpdate } from '../../../services/notion.js';
+import { blockRef, botName, formatParentCompact, notionErrors, NotionWriteCommand, parentRef, parseNotionId, recordValue, renderReceipt, requireYes, } from '../../../lib/notion/trash-move/support.js';
+export default class NotionBlockTrash extends NotionWriteCommand {
+    static errors = notionErrors();
+    static summary = 'Move a Notion block to Trash, or restore it with --restore';
+    static description = 'Soft-trash or restore a Notion block through the enrolled Notion bot. Block trash uses Notion DELETE, which is a soft delete.';
+    static examples = [
+        '<%= config.bin %> notion block trash 2ab6c741-4f85-4b17-9f88-e938fb5d0b66 --yes',
+        '<%= config.bin %> notion block trash 2ab6c741-4f85-4b17-9f88-e938fb5d0b66 --restore --yes',
+    ];
+    static aliases = [];
+    static flags = {
+        restore: Flags.boolean({ description: 'Restore the block 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 = {
+        block: Args.string({ description: 'Block ID.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionBlockTrash);
+        this.outputFlags = flags;
+        requireYes(flags.yes);
+        const blockId = parseNotionId(args.block);
+        const result = flags.restore ? await notionBlocksUpdate(blockId, { in_trash: false }) : await notionBlocksDelete(blockId);
+        const raw = this.rememberResult(result);
+        const block = blockRef(raw, blockId);
+        const parent = parentRef(recordValue(raw)?.parent);
+        const bot = botName(raw);
+        if (flags.restore) {
+            return {
+                action: 'block.restore',
+                block,
+                state: { before: 'in_trash', after: 'active' },
+                restored_under: parent,
+                ...(bot ? { bot } : {}),
+                notion_version: '2026-03-11',
+            };
+        }
+        return {
+            action: 'block.trash',
+            block,
+            state: { before: 'active', after: 'in_trash' },
+            destructive: true,
+            reversible: true,
+            undo: `escli notion block trash ${block.id} --restore --yes`,
+            ...(bot ? { bot } : {}),
+            notion_version: '2026-03-11',
+        };
+    }
+    render(data) {
+        const baseRows = [
+            ['action', data.action],
+            ['block', `${data.block.type} ${data.block.id}`],
+            ['preview', data.block.preview],
+            ['state', `${data.state.before} → ${data.state.after}`],
+        ];
+        if (data.action === 'block.restore') {
+            baseRows.push(['restored_under', formatParentCompact(data.restored_under)]);
+        }
+        else {
+            baseRows.push(['destructive', true], ['reversible', true], ['undo', data.undo ?? '']);
+        }
+        baseRows.push(['bot', data.bot ?? ''], ['notion_version', data.notion_version]);
+        return renderReceipt(baseRows);
+    }
+}
+//# sourceMappingURL=trash.js.map

package/dist/commands/notion/comments/add.js

@@ -0,0 +1,48 @@
+import { Args, Flags } from '@oclif/core';
+import { renderKv } from '../../../io/render-kv.js';
+import { notionCommentsCreate } from '../../../services/notion.js';
+import { createBodyFromMarkdown, formatAuthor, formatCreated, joinMarkdown, kvEntries, notionCommentErrors, NotionCommentsCommand, parseTarget, shapeReceipt, } from '../../../lib/notion/comments/shared.js';
+export default class NotionCommentsAdd extends NotionCommentsCommand {
+    static errors = notionCommentErrors;
+    static summary = 'Add a Notion comment to a page or block';
+    static description = 'Create a new page-level or block-level Notion comment as the bot.';
+    static examples = [
+        '<%= config.bin %> notion comments add 362e1f8b-0d45-4d7b-bd85-cfb7c26f00dc "Checked: the pricing table now matches the latest deck."',
+        '<%= config.bin %> notion comments add 8c3f2d49-3a4b-4f0f-8d2e-208a7623b44a "This sentence is stale; source deck says $249." --raw',
+    ];
+    static aliases = [];
+    static flags = {
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        target: Args.string({ description: 'Page or block ID/URL.', required: true }),
+        markdown: Args.string({ description: 'Inline comment markdown.', required: true, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionCommentsAdd);
+        const target = parseTarget(args.target);
+        const markdown = joinMarkdown(args.markdown);
+        const result = await notionCommentsCreate({ body: createBodyFromMarkdown(target, markdown) });
+        this.setNext(null);
+        if (flags.raw)
+            return this.setRaw(result.raw);
+        const action = target.kind === 'block' ? 'created_block_comment' : 'created_page_comment';
+        return shapeReceipt(result, { action, where: `${target.kind} ${target.id}`, body: markdown });
+    }
+    render(data) {
+        const receipt = data;
+        return renderKv(kvEntries({
+            created: receipt.created,
+            discussion_id: receipt.discussion_id,
+            action: receipt.action,
+            where: receipt.where,
+            author: formatAuthor({ author: receipt.author, author_kind: receipt.author_kind }),
+            created_time: formatCreated(receipt.created_time),
+            warning: receipt.warning,
+            body: receipt.body,
+        }));
+    }
+}
+//# sourceMappingURL=add.js.map

package/dist/commands/notion/comments/get.js

@@ -0,0 +1,42 @@
+import { Args, Flags } from '@oclif/core';
+import { renderKv } from '../../../io/render-kv.js';
+import { proxy } from '../../../services/notion.js';
+import { formatAuthor, formatCreated, kvEntries, notionCommentErrors, NotionCommentsCommand, shapeGet } from '../../../lib/notion/comments/shared.js';
+export default class NotionCommentsGet extends NotionCommentsCommand {
+    static errors = notionCommentErrors;
+    static summary = 'Get one Notion comment by ID';
+    static description = 'UNVERIFIED — GET /v1/comments/{id}; live-probe validates whether the endpoint exists before relying on this command.';
+    static examples = [
+        '<%= config.bin %> notion comments get cmt_7f2d',
+        '<%= config.bin %> notion comments get cmt_7f2d --raw',
+    ];
+    static aliases = [];
+    static flags = {
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        commentId: Args.string({ description: 'Comment ID.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionCommentsGet);
+        const result = await proxy('GET', `/v1/comments/${encodeURIComponent(args.commentId)}`);
+        this.setNext(null);
+        if (flags.raw)
+            return this.setRaw(result.raw);
+        return shapeGet(result);
+    }
+    render(data) {
+        const comment = data;
+        return renderKv(kvEntries({
+            id: comment.id,
+            discussion_id: comment.discussion_id,
+            where: comment.where,
+            author: formatAuthor(comment),
+            created: formatCreated(comment.created),
+            body: comment.body ?? comment.snippet,
+        }));
+    }
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/notion/comments/list.js

@@ -0,0 +1,55 @@
+import { Args, Flags } from '@oclif/core';
+import { renderKv } from '../../../io/render-kv.js';
+import { renderTable } from '../../../io/render-table.js';
+import { notionCommentsList } from '../../../services/notion.js';
+import { formatAuthor, formatCreated, formatTarget, notionCommentErrors, NotionCommentsCommand, parseTarget, renderContinuation, shapeList, } from '../../../lib/notion/comments/shared.js';
+export default class NotionCommentsList extends NotionCommentsCommand {
+    static errors = notionCommentErrors;
+    static summary = 'List Notion comments for a page or block';
+    static description = 'List open Notion comments attached to a page or block. Paginated; repeat with --next to continue.';
+    static examples = [
+        '<%= config.bin %> notion comments list 362e1f8b-0d45-4d7b-bd85-cfb7c26f00dc',
+        '<%= config.bin %> notion comments list https://notion.so/acme/Launch-Plan-362e?pvs=4 --next eyJ2Ijox',
+        '<%= config.bin %> notion comments list 362e1f8b-0d45-4d7b-bd85-cfb7c26f00dc --raw',
+    ];
+    static aliases = [];
+    static flags = {
+        next: Flags.string({ description: 'Notion pagination token from the previous response.' }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        target: Args.string({ description: 'Page or block ID/URL.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionCommentsList);
+        const target = parseTarget(args.target);
+        const result = await notionCommentsList(target.id, flags.next);
+        this.setNext(result.meta.next);
+        if (flags.raw)
+            return this.setRaw(result.raw);
+        return shapeList(result, target);
+    }
+    render(data) {
+        const shaped = data;
+        const header = renderKv({
+            target: formatTarget(shaped.target),
+            shown: `${shaped.summary.shown} ${shaped.summary.shown === 1 ? 'comment' : 'comments'} · threads: ${shaped.summary.threads} · human: ${shaped.summary.human_comments} · bot: ${shaped.summary.bot_comments}`,
+        });
+        const table = renderTable({
+            header: ['id', 'discussion', 'where', 'author', 'created', 'snippet'],
+            rows: shaped.comments.map((comment) => [
+                comment.id,
+                comment.discussion_id,
+                comment.where,
+                formatAuthor(comment),
+                formatCreated(comment.created, true),
+                comment.snippet,
+            ]),
+        });
+        const trailer = renderContinuation(shaped.next, shaped.remaining);
+        return [header, table, trailer].filter(Boolean).join('\n\n');
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/notion/comments/reply.js

@@ -0,0 +1,45 @@
+import { Args, Flags } from '@oclif/core';
+import { renderKv } from '../../../io/render-kv.js';
+import { notionCommentsCreate } from '../../../services/notion.js';
+import { formatAuthor, formatCreated, joinMarkdown, kvEntries, notionCommentErrors, NotionCommentsCommand, replyBodyFromMarkdown, shapeReceipt, } from '../../../lib/notion/comments/shared.js';
+export default class NotionCommentsReply extends NotionCommentsCommand {
+    static errors = notionCommentErrors;
+    static summary = 'Reply to a Notion discussion thread';
+    static description = 'Append a bot reply to an existing Notion discussion_id.';
+    static examples = [
+        '<%= config.bin %> notion comments reply disc_6a91 "Confirmed — I updated the pricing table to match the deck."',
+        '<%= config.bin %> notion comments reply disc_6a91 "Confirmed — I updated the pricing table to match the deck." --raw',
+    ];
+    static aliases = [];
+    static flags = {
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        discussionId: Args.string({ description: 'Discussion ID.', required: true }),
+        markdown: Args.string({ description: 'Inline comment markdown.', required: true, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionCommentsReply);
+        const markdown = joinMarkdown(args.markdown);
+        const result = await notionCommentsCreate({ body: replyBodyFromMarkdown(args.discussionId, markdown) });
+        this.setNext(null);
+        if (flags.raw)
+            return this.setRaw(result.raw);
+        return shapeReceipt(result, { action: 'replied_to_discussion', body: markdown, discussionId: args.discussionId });
+    }
+    render(data) {
+        const receipt = data;
+        return renderKv(kvEntries({
+            created: receipt.created,
+            discussion_id: receipt.discussion_id,
+            action: receipt.action,
+            author: formatAuthor({ author: receipt.author, author_kind: receipt.author_kind }),
+            created_time: formatCreated(receipt.created_time),
+            warning: receipt.warning,
+            body: receipt.body,
+        }));
+    }
+}
+//# sourceMappingURL=reply.js.map

package/dist/commands/notion/comments/thread.js

@@ -0,0 +1,87 @@
+import { Args, Flags } from '@oclif/core';
+import { renderKv } from '../../../io/render-kv.js';
+import { renderLabeled } from '../../../io/render-labeled.js';
+import { notionCommentsList } from '../../../services/notion.js';
+import { formatAuthor, formatCreated, formatTarget, notionCommentErrors, NotionCommentsCommand, parseTarget, renderContinuation, shapeThread, } from '../../../lib/notion/comments/shared.js';
+const MAX_THREAD_PAGES = 25;
+export default class NotionCommentsThread extends NotionCommentsCommand {
+    static errors = notionCommentErrors;
+    static summary = 'Show one Notion discussion thread';
+    static description = 'Show comments in one discussion thread for a page or block. Not paginated by CLI contract; use comments list --next for broader scanning.';
+    static examples = [
+        '<%= config.bin %> notion comments thread 362e1f8b-0d45-4d7b-bd85-cfb7c26f00dc disc_6a91',
+        '<%= config.bin %> notion comments thread 362e1f8b-0d45-4d7b-bd85-cfb7c26f00dc disc_6a91 --raw',
+    ];
+    static aliases = [];
+    static flags = {
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        target: Args.string({ description: 'Page or block ID/URL.', required: true }),
+        discussionId: Args.string({ description: 'Discussion ID.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionCommentsThread);
+        const target = parseTarget(args.target);
+        // Page until we find at least one comment for this discussion or pages
+        // are exhausted. Without this, a discussion that lives past the first
+        // page produces a false notion.not_found despite existing in Notion.
+        let cursor;
+        const aggregated = [];
+        let pageIndex = 0;
+        let raw;
+        let lastResult;
+        while (pageIndex < MAX_THREAD_PAGES) {
+            const result = await notionCommentsList(target.id, cursor);
+            lastResult = result;
+            raw = result.raw;
+            const data = result.data;
+            if (Array.isArray(data?.results))
+                aggregated.push(...data.results);
+            const hasMore = data?.has_more === true && typeof data.next_cursor === 'string' && data.next_cursor.length > 0;
+            // Stop early if we have already found at least one comment for the
+            // requested discussion — that's enough for shapeThread to succeed and
+            // saves further round-trips.
+            const matched = aggregated.some((comment) => {
+                const record = comment;
+                return record !== null && typeof record === 'object' && record.discussion_id === args.discussionId;
+            });
+            if (matched || !hasMore)
+                break;
+            cursor = data.next_cursor;
+            pageIndex += 1;
+        }
+        this.setNext(null);
+        if (flags.raw)
+            return this.setRaw(raw);
+        const merged = {
+            data: { results: aggregated },
+            raw,
+            meta: lastResult?.meta ?? { next: null, notion_version: '2026-03-11' },
+        };
+        return shapeThread(merged, target, args.discussionId);
+    }
+    render(data) {
+        const thread = data;
+        const summary = {
+            discussion_id: thread.discussion_id,
+            target: thread.target ? formatTarget(thread.target) : undefined,
+            shown: thread.summary.shown,
+            bot_replied: thread.summary.bot_replied,
+            last_author: thread.summary.last_author,
+            next_action: thread.summary.next_action,
+            partial_thread: thread.summary.partial_thread,
+            total_seen_for_thread: thread.summary.total_seen_for_thread,
+        };
+        const header = renderKv(Object.entries(summary).filter(([, value]) => value !== undefined));
+        const body = renderLabeled(thread.comments.map((comment) => ({
+            label: `${comment.id} · ${formatAuthor(comment)} · ${formatCreated(comment.created)}`,
+            body: comment.body ?? comment.snippet,
+        })));
+        const trailer = renderContinuation(null);
+        return [header, body, trailer].filter(Boolean).join('\n\n');
+    }
+}
+//# sourceMappingURL=thread.js.map