@eightstate/escli 0.5.0 → 0.7.1

package/dist/io/render-kv.js

@@ -0,0 +1,12 @@
+export function renderKv(input) {
+    const entries = Array.isArray(input) ? input : Object.entries(input);
+    return entries.map(([key, value]) => `${key}: ${formatValue(value)}`).join('\n');
+}
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=render-kv.js.map

package/dist/io/render-labeled.js

@@ -0,0 +1,16 @@
+import { renderKv } from './render-kv.js';
+export function renderLabeled(records) {
+    return records.map(renderRecord).join('\n');
+}
+function renderRecord(record) {
+    const lines = [`--- ${record.label}`];
+    if (record.fields) {
+        const rendered = renderKv(record.fields);
+        if (rendered)
+            lines.push(rendered);
+    }
+    if (record.body)
+        lines.push(record.body);
+    return lines.join('\n');
+}
+//# sourceMappingURL=render-labeled.js.map

package/dist/io/render-table.js

@@ -0,0 +1,19 @@
+export function renderTable(input) {
+    const widths = input.header.map((heading, index) => Math.max(cellWidth(heading), ...input.rows.map((row) => cellWidth(formatCell(row[index])))));
+    const header = renderRow(input.header, widths);
+    const separator = renderRow(widths.map((width) => '-'.repeat(Math.max(3, width))), widths);
+    const body = input.rows.map((row) => renderRow(input.header.map((_, index) => formatCell(row[index])), widths));
+    return [header, separator, ...body].join('\n');
+}
+function renderRow(cells, widths) {
+    return `| ${cells.map((cell, index) => formatCell(cell).padEnd(widths[index] ?? 0)).join(' | ')} |`;
+}
+function formatCell(value) {
+    if (value === null || value === undefined)
+        return '';
+    return String(value).replace(/\r?\n/gu, ' ');
+}
+function cellWidth(value) {
+    return formatCell(value).length;
+}
+//# sourceMappingURL=render-table.js.map

package/dist/io/render-trailer.js

@@ -0,0 +1,7 @@
+export function renderTrailer(input) {
+    if (!input.next)
+        return '';
+    const prefix = typeof input.remaining === 'number' && Number.isFinite(input.remaining) && input.remaining > 0 ? `+${Math.trunc(input.remaining)} more` : 'more';
+    return `${prefix} — repeat with --next ${input.next}`;
+}
+//# sourceMappingURL=render-trailer.js.map

package/dist/lib/manifest.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { EnvelopeSchema } from '@eightstate/contracts/envelope';
 import { ManifestSchema } from '@eightstate/contracts/manifest';
 import { commandRegistry } from './registry.js';
+import packageJson from '../../package.json' with { type: 'json' };
 function jsonSchema(schema) {
     return z.toJSONSchema(schema);
 }
@@ -25,7 +26,7 @@ export function buildManifest(compact = false, scope) {
             }),
         };
     }
-    return ManifestSchema.parse({ version: '0.5.0', commands });
+    return ManifestSchema.parse({ version: packageJson.version, commands });
 }
 function isInScope(commandId, scope) {
     if (!scope)
@@ -63,5 +64,5 @@ function inferOptionType(name, value) {
         return 'integer';
     return 'string';
 }
-const integerFlags = new Set(['compression', 'speakers-expected', 'limit', 'tokens', 'page', 'max-results', 'days', 'timeout']);
+const integerFlags = new Set(['compression', 'speakers-expected', 'limit', 'tokens', 'page', 'max-results', 'days', 'timeout', 'max-wait']);
 //# sourceMappingURL=manifest.js.map

package/dist/lib/notion/comments/shared.js

@@ -0,0 +1,366 @@
+import { Errors } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { BaseCommand } from '../../../base-command.js';
+import { writeStderr, writeStdout } from '../../../io/io.js';
+import { renderTrailer } from '../../../io/render-trailer.js';
+import { EscliError } from '../../../lib/escli-error.js';
+import { NOTION_VERSION } from '../../../services/notion.js';
+import { hasManifestFlag } from '../manifest-pass.js';
+export const notionCommentErrors = [
+    ErrorCode.UsageInvalid,
+    ErrorCode.UsageRequired,
+    ErrorCode.UsageUnknownFlag,
+    ErrorCode.NotionUnauthorized,
+    ErrorCode.NotionRestricted,
+    ErrorCode.NotionNotFound,
+    ErrorCode.NotionRateLimited,
+    ErrorCode.NotionValidation,
+    ErrorCode.NotionConflict,
+    ErrorCode.NotionTimeoutUncertain,
+    ErrorCode.NotionEnrollmentRequired,
+    ErrorCode.GateInvalidResponse,
+    ErrorCode.NetworkError,
+    ErrorCode.NetworkTimeout,
+    ErrorCode.ServiceUnavailable,
+    ErrorCode.ApiError,
+];
+export class NotionCommentsCommand extends BaseCommand {
+    rawMode = false;
+    nextToken = null;
+    async run() {
+        if (hasManifestFlag(this.argv)) {
+            await super.run();
+            return;
+        }
+        try {
+            const flags = flagsFromArgv(this.argv);
+            const data = await this.execute();
+            if (this.rawMode && !flags.json) {
+                await writeStdout(`${JSON.stringify(data, null, 2)}\n`);
+                return;
+            }
+            if (flags.json) {
+                await writeStdout(`${JSON.stringify(successEnvelope(data, this.nextToken))}\n`);
+                return;
+            }
+            await writeStdout(`${this.render(data)}\n`);
+        }
+        catch (error) {
+            this.parsed = true;
+            const escliError = toEscliError(error);
+            process.exitCode = escliError.exitCode;
+            const flags = flagsFromArgv(this.argv);
+            if (flags.json) {
+                await writeStdout(`${JSON.stringify(errorEnvelope(escliError))}\n`);
+                return;
+            }
+            await writeStderr(`${escliError.message}\n`);
+        }
+    }
+    setRaw(raw) {
+        this.rawMode = true;
+        return raw;
+    }
+    setNext(next) {
+        this.nextToken = next ?? null;
+    }
+}
+export function successEnvelope(data, next) {
+    return { ok: true, data, error: null, meta: { next, notion_version: NOTION_VERSION } };
+}
+export function errorEnvelope(error) {
+    return {
+        ok: false,
+        data: null,
+        error: { code: error.code, message: error.message, details: error.details, remediation: error.remediation, cause_code: error.causeCode },
+        meta: { next: null, notion_version: NOTION_VERSION },
+    };
+}
+export function parseTarget(input) {
+    const urlTarget = parseUrlTarget(input);
+    if (urlTarget)
+        return urlTarget;
+    return { kind: inferTargetKind(input), id: normalizeId(input) };
+}
+export function formatTarget(target) {
+    if (!target)
+        return '';
+    return `${target.kind} ${target.id}${target.title ? ` · ${target.title}` : ''}`;
+}
+export function formatAuthor(comment) {
+    const author = comment.author ?? 'unknown';
+    return comment.author_kind && comment.author_kind !== 'unknown' ? `${author} (${comment.author_kind})` : author;
+}
+export function formatCreated(value, compact = false) {
+    if (!value)
+        return '';
+    const withoutMillis = value.replace(/\.000Z$/u, 'Z');
+    if (!compact)
+        return withoutMillis;
+    return withoutMillis.replace('T', ' ').replace(/:\d{2}Z$/u, 'Z');
+}
+export function renderContinuation(next, remaining) {
+    return renderTrailer({ next, remaining });
+}
+export function shapeList(result, target) {
+    const data = recordValue(result.data);
+    if (isBrokerListData(data))
+        return { ...data, next: result.meta.next ?? data.next ?? null };
+    const comments = arrayValue(data?.results).map(shapeComment);
+    const shapedTarget = targetFromData(data, target);
+    return {
+        target: shapedTarget,
+        comments,
+        summary: summarize(comments),
+        next: result.meta.next,
+        remaining: remainingCount(data, comments.length),
+    };
+}
+export function shapeGet(result) {
+    const data = recordValue(result.data);
+    if (isBrokerCommentData(data))
+        return data;
+    return shapeComment(data);
+}
+export function shapeThread(result, target, discussionId) {
+    const data = recordValue(result.data);
+    if (isBrokerThreadData(data))
+        return data;
+    const comments = arrayValue(data?.results).map(shapeComment).filter((comment) => comment.discussion_id === discussionId);
+    if (comments.length === 0) {
+        throw new EscliError(`Discussion not found or bot cannot access it: ${discussionId}`, {
+            code: ErrorCode.NotionNotFound,
+            exitCode: ExitCodes.NotFound,
+            details: { discussion_id: discussionId },
+        });
+    }
+    const last = comments.at(-1);
+    const botReplied = comments.some((comment) => comment.author_kind === 'bot');
+    return {
+        discussion_id: discussionId,
+        target: targetFromData(data, target),
+        comments,
+        summary: {
+            shown: comments.length,
+            bot_replied: botReplied,
+            last_author: last?.author_kind,
+            next_action: `escli notion comments reply ${discussionId} <markdown>`,
+        },
+    };
+}
+export function shapeReceipt(result, fallback) {
+    const data = recordValue(result.data);
+    if (isBrokerReceiptData(data))
+        return data;
+    const id = stringValue(data?.id) ?? '';
+    const body = plainText(data) || fallback.body;
+    const author = authorName(data);
+    const authorKind = authorKindValue(data);
+    const discussionId = stringValue(data?.discussion_id) ?? fallback.discussionId;
+    const partial = !discussionId && !data?.created_time && !data?.rich_text;
+    return {
+        created: id,
+        discussion_id: discussionId,
+        action: fallback.action,
+        where: fallback.where,
+        author,
+        author_kind: authorKind,
+        created_time: formatCreated(stringValue(data?.created_time)),
+        body,
+        warning: partial ? 'partial_comment_response' : undefined,
+    };
+}
+export function createBodyFromMarkdown(target, markdown) {
+    return { parent: target.kind === 'block' ? { block_id: target.id } : { page_id: target.id }, markdown };
+}
+export function replyBodyFromMarkdown(discussionId, markdown) {
+    return { discussion_id: discussionId, markdown };
+}
+export function joinMarkdown(value) {
+    const markdown = Array.isArray(value) ? value.join(' ') : value ?? '';
+    if (markdown.trim().length === 0) {
+        throw new EscliError('comments write requires a non-empty body.', { code: ErrorCode.UsageRequired, exitCode: ExitCodes.Usage });
+    }
+    return markdown;
+}
+export function kvEntries(input) {
+    return Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== '');
+}
+function shapeComment(value) {
+    const data = recordValue(value);
+    const parent = recordValue(data?.parent);
+    const where = whereFromParent(parent);
+    return {
+        id: stringValue(data?.id) ?? '',
+        discussion_id: stringValue(data?.discussion_id),
+        where,
+        block_id: stringValue(parent?.block_id),
+        author: authorName(data),
+        author_kind: authorKindValue(data),
+        created: formatCreated(stringValue(data?.created_time) ?? stringValue(data?.created)),
+        snippet: stringValue(data?.snippet) ?? snippet(plainText(data)),
+        body: stringValue(data?.body) ?? plainText(data),
+    };
+}
+function summarize(comments) {
+    return {
+        shown: comments.length,
+        threads: new Set(comments.map((comment) => comment.discussion_id).filter(Boolean)).size,
+        bot_comments: comments.filter((comment) => comment.author_kind === 'bot').length,
+        human_comments: comments.filter((comment) => comment.author_kind === 'person').length,
+    };
+}
+function targetFromData(data, fallback) {
+    const target = recordValue(data?.target);
+    if (target) {
+        return {
+            kind: target.kind === 'block' ? 'block' : 'page',
+            id: stringValue(target.id) ?? fallback.id,
+            title: stringValue(target.title),
+        };
+    }
+    const firstParent = recordValue(recordValue(arrayValue(data?.results)[0])?.parent);
+    const kind = firstParent?.type === 'block_id' || firstParent?.block_id ? 'block' : fallback.kind;
+    const id = stringValue(firstParent?.block_id) ?? stringValue(firstParent?.page_id) ?? fallback.id;
+    return { kind, id, title: fallback.title ?? inferTitle(data) };
+}
+function inferTitle(data) {
+    return stringValue(data?.title);
+}
+function whereFromParent(parent) {
+    if (!parent)
+        return undefined;
+    if (parent.type === 'page_id' && stringValue(parent.page_id))
+        return `page ${parent.page_id}`;
+    if (parent.type === 'block_id' && stringValue(parent.block_id))
+        return `block ${parent.block_id}`;
+    if (stringValue(parent.page_id))
+        return `page ${parent.page_id}`;
+    if (stringValue(parent.block_id))
+        return `block ${parent.block_id}`;
+    return undefined;
+}
+function plainText(data) {
+    const richText = arrayValue(data?.rich_text);
+    if (richText.length === 0)
+        return '';
+    return richText.map((item) => stringValue(recordValue(item)?.plain_text) ?? stringValue(recordValue(recordValue(item)?.text)?.content) ?? '').join('');
+}
+function snippet(value) {
+    const compact = value.replace(/\s+/gu, ' ').trim();
+    return compact.length > 140 ? `${compact.slice(0, 137)}…` : compact;
+}
+function authorName(data) {
+    return stringValue(data?.display_name) ?? stringValue(recordValue(data?.created_by)?.name) ?? stringValue(recordValue(data?.created_by)?.id);
+}
+function authorKindValue(data) {
+    const explicit = stringValue(data?.author_kind);
+    if (explicit === 'person' || explicit === 'bot')
+        return explicit;
+    const createdBy = recordValue(data?.created_by);
+    if (createdBy?.type === 'bot' || stringValue(createdBy?.id)?.startsWith('bot_'))
+        return 'bot';
+    if (createdBy?.type === 'person' || stringValue(createdBy?.id)?.startsWith('usr_'))
+        return 'person';
+    return undefined;
+}
+function remainingCount(data, shown) {
+    const remaining = numberValue(data?.remaining);
+    if (remaining !== undefined)
+        return remaining;
+    if (data?.has_more === true)
+        return 1;
+    const total = numberValue(data?.total);
+    return total !== undefined && total > shown ? total - shown : null;
+}
+function parseUrlTarget(input) {
+    try {
+        const url = new URL(input);
+        const hashId = firstNotionId(url.hash);
+        if (hashId)
+            return { kind: 'block', id: hashId };
+        const id = firstNotionId(`${url.pathname}${url.search}`);
+        return id ? { kind: 'page', id } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function firstNotionId(value) {
+    const uuid = value.match(/[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}/iu)?.[0];
+    return uuid ? normalizeId(uuid) : undefined;
+}
+function normalizeId(value) {
+    const trimmed = value.trim();
+    const uuid = trimmed.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/iu)?.[0];
+    if (uuid)
+        return uuid.toLowerCase();
+    const compactUuid = trimmed.match(/[0-9a-f]{32}/iu)?.[0];
+    if (!compactUuid)
+        return trimmed;
+    return `${compactUuid.slice(0, 8)}-${compactUuid.slice(8, 12)}-${compactUuid.slice(12, 16)}-${compactUuid.slice(16, 20)}-${compactUuid.slice(20)}`.toLowerCase();
+}
+function inferTargetKind(input) {
+    return /(?:^|[-_])block(?:$|[-_])/iu.test(input) || /#[-\w]*[0-9a-f]{32}/iu.test(input) ? 'block' : 'page';
+}
+function flagsFromArgv(argv) {
+    return { json: argv.includes('--json') };
+}
+function toEscliError(error) {
+    if (error instanceof EscliError)
+        return error;
+    if (error instanceof z.ZodError) {
+        return new EscliError('input validation failed', { code: ErrorCode.ValidationFailed, exitCode: ExitCodes.Usage, details: error.issues });
+    }
+    if (error instanceof Errors.ExitError) {
+        return new EscliError(error.message, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage, details: { oclif_exit: error.oclif?.exit } });
+    }
+    if (error instanceof Errors.CLIError) {
+        return new EscliError(cleanOclifMessage(error.message), { code: classifyOclifUsageError(error), exitCode: ExitCodes.Usage, details: { oclif_exit: error.oclif?.exit } });
+    }
+    if (error instanceof Error)
+        return new EscliError(error.message, { code: ErrorCode.Internal });
+    return new EscliError('unknown error', { code: ErrorCode.Unknown, details: error });
+}
+function classifyOclifUsageError(error) {
+    const name = error.constructor.name;
+    const message = error.message;
+    if (name === 'NonExistentFlagsError' || message.startsWith('Nonexistent flag') || message.startsWith('Unexpected flag'))
+        return ErrorCode.UsageUnknownFlag;
+    if (name === 'RequiredArgsError' || message.startsWith('Missing ') || message.includes('expects a value'))
+        return ErrorCode.UsageRequired;
+    if (message.includes('command ') && message.includes(' not found'))
+        return ErrorCode.UsageUnknownCommand;
+    return ErrorCode.UsageInvalid;
+}
+function cleanOclifMessage(message) {
+    return message.replace(/\nSee more help with --help$/u, '');
+}
+function isBrokerListData(data) {
+    return Boolean(data && recordValue(data.target) && Array.isArray(data.comments) && recordValue(data.summary));
+}
+function isBrokerCommentData(data) {
+    return Boolean(data && typeof data.id === 'string' && (typeof data.body === 'string' || typeof data.snippet === 'string') && !Array.isArray(data.results));
+}
+function isBrokerThreadData(data) {
+    return Boolean(data && typeof data.discussion_id === 'string' && Array.isArray(data.comments) && recordValue(data.summary));
+}
+function isBrokerReceiptData(data) {
+    return Boolean(data && typeof data.created === 'string' && typeof data.action === 'string');
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function numberValue(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+//# sourceMappingURL=shared.js.map