@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/cli/comment/view.js

@@ -0,0 +1,197 @@
+import { stateCodeToName } from '../../services/Comment';
+import { asRecord, first, firstString, formatScalar, unwrapDocument, } from '../../services/Renderer/content';
+import { tryFormatTimestamp } from '../../services/Renderer/datetime';
+import { ANSI, formatStateBadge, frontmatter, renderMarkdownToAnsi, renderMetadataBlock, SEPARATOR_WIDTH, visibleLen, wrap, } from '../render';
+// ---------------------------------------------------------------------------
+// Field helpers (shared by single + list views)
+// ---------------------------------------------------------------------------
+const normalize = (data) => asRecord(unwrapDocument(data));
+const stateLabel = (raw) => {
+    if (typeof raw === 'number')
+        return stateCodeToName(raw) ?? String(raw);
+    if (typeof raw === 'string')
+        return raw;
+    return '';
+};
+const colorForCommentState = (raw, color) => {
+    const label = stateLabel(raw);
+    if (!label)
+        return undefined;
+    if (label === 'unread')
+        return wrap(ANSI.yellow, label, color);
+    if (label === 'read')
+        return wrap(ANSI.green, label, color);
+    if (label === 'junk')
+        return wrap(ANSI.red, label, color);
+    return formatStateBadge(label, color) ?? label;
+};
+const indentBody = (s, indent = '   ') => s
+    .replace(/\s+$/, '')
+    .split('\n')
+    .map((line) => `${indent}${line}`)
+    .join('\n');
+const authorOf = (doc) => {
+    const reader = asRecord(first(doc, 'reader'));
+    if (Object.keys(reader).length > 0) {
+        const name = firstString(reader, 'nickname', 'name');
+        if (name)
+            return name;
+    }
+    return firstString(doc, 'author') || '(anonymous)';
+};
+const refLabel = (doc) => {
+    const refType = firstString(doc, 'ref_type', 'refType');
+    const ref = asRecord(first(doc, 'ref'));
+    const title = firstString(ref, 'title', 'slug', 'id');
+    if (refType && title)
+        return `${refType}:${title}`;
+    if (refType)
+        return refType;
+    return '';
+};
+const collectDetailFields = (doc) => {
+    const fields = [
+        ['id', first(doc, 'id')],
+        ['author', authorOf(doc)],
+        ['mail', first(doc, 'mail')],
+        ['url', first(doc, 'url')],
+        ['ip', first(doc, 'ip')],
+        ['location', first(doc, 'location')],
+        ['ref', refLabel(doc)],
+        ['state', stateLabel(first(doc, 'state'))],
+        ['pin', first(doc, 'pin')],
+        ['is_whispers', first(doc, 'is_whispers', 'isWhispers')],
+        ['created_at', first(doc, 'created_at', 'createdAt')],
+    ];
+    return fields.filter(([, value]) => value !== undefined && value !== null && value !== '');
+};
+// ---------------------------------------------------------------------------
+// Single-comment view
+// ---------------------------------------------------------------------------
+const renderCommentReadable = (data, color) => {
+    const doc = normalize(data);
+    const author = authorOf(doc);
+    const title = `comment from ${author}`;
+    return renderMetadataBlock({
+        title,
+        kind: 'comment',
+        fields: collectDetailFields(doc),
+        body: firstString(doc, 'text') || undefined,
+        bodyFormat: 'markdown',
+    }, { color });
+};
+const renderCommentLlm = (data) => {
+    const doc = normalize(data);
+    const fm = frontmatter({
+        title: `comment ${firstString(doc, 'id') || ''}`.trim(),
+        fields: collectDetailFields(doc),
+    });
+    const text = firstString(doc, 'text');
+    return text ? `${fm}\n\n${text}` : fm;
+};
+export const commentView = {
+    kind: 'comment',
+    modes: new Set(['readable', 'llm']),
+    readable: (data, ctx) => renderCommentReadable(data, ctx.color),
+    llm: (data) => renderCommentLlm(data),
+};
+// ---------------------------------------------------------------------------
+// List view
+// ---------------------------------------------------------------------------
+const renderListHeader = (payload, rowCount, color) => {
+    const envelopeMeta = asRecord(first(payload, 'meta'));
+    const pagination = asRecord(first(envelopeMeta, 'pagination'));
+    const page = first(pagination, 'page', 'currentPage');
+    const size = first(pagination, 'size', 'pageSize');
+    const total = first(pagination, 'total', 'totalCount', 'total_count');
+    const headerParts = [`count: ${rowCount}`];
+    if (page !== undefined)
+        headerParts.push(`page: ${formatScalar(page)}`);
+    if (size !== undefined)
+        headerParts.push(`size: ${formatScalar(size)}`);
+    if (total !== undefined)
+        headerParts.push(`total: ${formatScalar(total)}`);
+    const heading = wrap(ANSI.bold, 'Comments', color);
+    const ruleLen = Math.min(Math.max(visibleLen('Comments'), 24), SEPARATOR_WIDTH);
+    const rule = wrap(ANSI.dim, '─'.repeat(ruleLen), color);
+    const metaLine = wrap(ANSI.dim, headerParts.join('  ·  '), color);
+    return `${heading}\n${rule}\n${metaLine}`;
+};
+const renderListItem = (doc, index, color) => {
+    const author = authorOf(doc);
+    const id = firstString(doc, 'id');
+    const stateBadge = colorForCommentState(first(doc, 'state'), color) ??
+        stateLabel(first(doc, 'state'));
+    const ref = refLabel(doc);
+    const created = first(doc, 'created_at', 'createdAt');
+    const lines = [];
+    // Header: "1. <author>  [state]  <id>"
+    const indexLabel = wrap(ANSI.dim, `${index + 1}.`, color);
+    const authorBold = wrap(ANSI.bold, author, color);
+    const idDim = id ? wrap(ANSI.dim, `#${id}`, color) : '';
+    const header = [indexLabel, authorBold, `[${stateBadge}]`, idDim]
+        .filter(Boolean)
+        .join('  ');
+    lines.push(header);
+    // Meta line: ref · created_at
+    const metaParts = [];
+    if (ref)
+        metaParts.push(ref);
+    if (created !== undefined) {
+        metaParts.push(tryFormatTimestamp(created, { style: 'rel' }) ?? formatScalar(created));
+    }
+    if (metaParts.length > 0) {
+        lines.push(wrap(ANSI.dim, `   ${metaParts.join('  ·  ')}`, color));
+    }
+    // Body — full text, indented to align with list item.
+    const text = firstString(doc, 'text');
+    if (text)
+        lines.push(indentBody(text));
+    return lines.join('\n');
+};
+const renderCommentListReadable = (data, color) => {
+    const payload = asRecord(data);
+    const rows = Array.isArray(payload.data)
+        ? payload.data
+        : Array.isArray(data)
+            ? data
+            : [];
+    const header = renderListHeader(payload, rows.length, color);
+    if (rows.length === 0) {
+        const empty = wrap(ANSI.dim, '(no comments)', color);
+        return `${header}\n\n${empty}`;
+    }
+    const items = rows.map((row, index) => renderListItem(asRecord(row), index, color));
+    return `${header}\n\n${items.join('\n\n')}`;
+};
+const renderCommentListLlm = (data) => {
+    const payload = asRecord(data);
+    const rows = Array.isArray(payload.data)
+        ? payload.data
+        : Array.isArray(data)
+            ? data
+            : [];
+    if (rows.length === 0) {
+        // Render the markdown shape so consumers still see a header.
+        return renderMarkdownToAnsi('# Comments\n\n_no comments_\n', {
+            color: false,
+        });
+    }
+    return rows
+        .map((row) => {
+        const doc = asRecord(row);
+        const fm = frontmatter({
+            title: `comment ${firstString(doc, 'id') || ''}`.trim(),
+            fields: collectDetailFields(doc),
+        });
+        const text = firstString(doc, 'text');
+        return text ? `${fm}\n\n${text}` : fm;
+    })
+        .join('\n\n---\n\n');
+};
+export const commentListView = {
+    kind: 'comment-list',
+    modes: new Set(['readable', 'llm']),
+    readable: (data, ctx) => renderCommentListReadable(data, ctx.color),
+    llm: (data) => renderCommentListLlm(data),
+};

package/dist/src/cli/config/edit.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+export declare const edit: Command.Command<"edit", Api | Renderer | Editor, import("../../services/Api").ApiError, {}>;

package/dist/src/cli/config/edit.js

@@ -0,0 +1,36 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+export const edit = Command.make('edit', {}, () => Effect.gen(function* () {
+    const api = yield* Api;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    const current = yield* api.request('/options');
+    const initial = JSON.stringify(current ?? {}, null, 2);
+    const next = yield* editor.openEditor({
+        filename: 'mxs-config.json',
+        initialContent: initial,
+    });
+    if (next.trim() === initial.trim()) {
+        yield* renderer.emitInfo('no changes');
+        return;
+    }
+    const parsed = yield* Effect.try({
+        try: () => JSON.parse(next),
+        catch: (err) => new ValidationFailed({
+            message: `invalid JSON: ${err?.message ?? String(err)}`,
+        }),
+    });
+    const results = {};
+    for (const [k, v] of Object.entries(parsed)) {
+        const r = yield* api.request(`/options/${encodeURIComponent(k)}`, {
+            method: 'PATCH',
+            body: v,
+        });
+        results[k] = r;
+    }
+    yield* renderer.emitSuccess(results);
+}));

package/dist/src/cli/config/get.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const get: Command.Command<"get", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly key: string;
+}>;

package/dist/src/cli/config/get.js

@@ -0,0 +1,11 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const key = Args.text({ name: 'key' });
+export const get = Command.make('get', { key }, ({ key }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/options/${encodeURIComponent(key)}`);
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/config/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+export declare const configCmd: Command.Command<"config", import("../../services/Api").Api | import("../ai/_poll").Renderer | import("../../services/Editor").Editor, import("../../services/Api").ApiError, {
+    readonly subcommand: import("effect/Option").Option<{} | {
+        readonly key: string;
+    } | {} | {
+        readonly key: string;
+        readonly value: string;
+        readonly type: import("effect/Option").Option<"string" | "number" | "json" | "bool">;
+    }>;
+}>;

package/dist/src/cli/config/index.js

@@ -0,0 +1,22 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { edit } from './edit';
+import { get } from './get';
+import { list } from './list';
+import { set } from './set';
+const help = registerCommandHelp({
+    name: 'config',
+    description: 'manage server options',
+    skillChapter: 'commands-config',
+    verbs: [
+        { name: 'list', description: 'list all server options' },
+        { name: 'get', args: ['<key>'], description: 'read one server option' },
+        {
+            name: 'set',
+            args: ['<key>', '<value>', '[--type <json/string/number/bool>]'],
+            description: 'set a server option',
+        },
+        { name: 'edit', description: 'edit all server options via $EDITOR' },
+    ],
+});
+export const configCmd = Command.make('config').pipe(Command.withDescription(help.description), Command.withSubcommands([list, get, set, edit]));

package/dist/src/cli/config/list.d.ts

@@ -0,0 +1,4 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const list: Command.Command<"list", Api | Renderer, import("../../services/Api").ApiError, {}>;

package/dist/src/cli/config/list.js

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export const list = Command.make('list', {}, () => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/options');
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/config/set.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const set: Command.Command<"set", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly key: string;
+    readonly value: string;
+    readonly type: Option.Option<"string" | "number" | "json" | "bool">;
+}>;

package/dist/src/cli/config/set.js

@@ -0,0 +1,48 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const key = Args.text({ name: 'key' });
+const value = Args.text({ name: 'value' });
+const type_ = Options.choice('type', [
+    'json',
+    'string',
+    'number',
+    'bool',
+]).pipe(Options.optional);
+const coerce = (raw, type) => {
+    if (type === 'string')
+        return Effect.succeed(raw);
+    if (type === 'number') {
+        const n = Number(raw);
+        if (Number.isNaN(n)) {
+            return Effect.fail(new ValidationFailed({ message: `invalid number: ${raw}` }));
+        }
+        return Effect.succeed(n);
+    }
+    if (type === 'bool')
+        return Effect.succeed(raw === 'true');
+    // json | undefined → try JSON.parse; on failure fall back to raw string when
+    // type was not explicitly 'json', else fail.
+    try {
+        return Effect.succeed(JSON.parse(raw));
+    }
+    catch {
+        if (type === 'json') {
+            return Effect.fail(new ValidationFailed({ message: `invalid JSON: ${raw}` }));
+        }
+        return Effect.succeed(raw);
+    }
+};
+export const set = Command.make('set', { key, value, type: type_ }, ({ key, value, type }) => Effect.gen(function* () {
+    const t = Option.getOrUndefined(type);
+    const coerced = yield* coerce(value, t);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/options/${encodeURIComponent(key)}`, {
+        method: 'PATCH',
+        body: coerced,
+    });
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/draft/_shared.d.ts

@@ -0,0 +1,27 @@
+export type DraftRefType = 'post' | 'note' | 'page';
+export declare const REF_TYPE_TO_RESOURCE: Record<DraftRefType, string>;
+export interface DraftRow {
+    id?: string;
+    refType?: DraftRefType;
+    refId?: string | null;
+    title?: string;
+    text?: string;
+    content?: string | null;
+    contentFormat?: string;
+    meta?: Record<string, unknown> | null;
+    typeSpecificData?: Record<string, unknown> | string | null;
+}
+export declare const splitDraftBody: (payload: Record<string, unknown>) => Record<string, unknown>;
+export declare const parseTypeSpecificData: (raw: DraftRow["typeSpecificData"]) => Record<string, unknown>;
+/**
+ * The response interceptor snake_cases keys at every depth, but the request
+ * pipe only camelizes the body's top level — nested subtrees (like `meta`)
+ * must be restored before being sent back, or `skillIds` round-trips into a
+ * stored `skill_ids`. Best-effort inverse: keys that legitimately contained
+ * underscores were already mangled by the response side.
+ */
+export declare const camelizeDeep: (value: unknown) => unknown;
+/** The server serializes response keys to snake_case; normalize back. */
+export declare const normalizeDraftRow: (row: unknown) => DraftRow;
+/** Single-object responses may arrive wrapped in an outer `data` envelope. */
+export declare const unwrapData: <T>(res: unknown) => T;

package/dist/src/cli/draft/_shared.js

@@ -0,0 +1,85 @@
+/** Draft-native fields; everything else rides along in `typeSpecificData`. */
+const DRAFT_CORE_KEYS = new Set([
+    'title',
+    'text',
+    'content',
+    'contentFormat',
+    'meta',
+]);
+export const REF_TYPE_TO_RESOURCE = {
+    post: 'posts',
+    note: 'notes',
+    page: 'pages',
+};
+export const splitDraftBody = (payload) => {
+    const draftBody = {};
+    const typeSpecificData = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (DRAFT_CORE_KEYS.has(key))
+            draftBody[key] = value;
+        else
+            typeSpecificData[key] = value;
+    }
+    if (Object.keys(typeSpecificData).length > 0) {
+        draftBody.typeSpecificData = typeSpecificData;
+    }
+    return draftBody;
+};
+export const parseTypeSpecificData = (raw) => {
+    if (!raw)
+        return {};
+    if (typeof raw === 'object')
+        return raw;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * The response interceptor snake_cases keys at every depth, but the request
+ * pipe only camelizes the body's top level — nested subtrees (like `meta`)
+ * must be restored before being sent back, or `skillIds` round-trips into a
+ * stored `skill_ids`. Best-effort inverse: keys that legitimately contained
+ * underscores were already mangled by the response side.
+ */
+export const camelizeDeep = (value) => {
+    if (Array.isArray(value))
+        return value.map(camelizeDeep);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [
+            k.replaceAll(/_([\da-z])/g, (_, c) => c.toUpperCase()),
+            camelizeDeep(v),
+        ]));
+    }
+    return value;
+};
+/** The server serializes response keys to snake_case; normalize back. */
+export const normalizeDraftRow = (row) => {
+    if (!row || typeof row !== 'object')
+        return {};
+    const r = row;
+    const pick = (camel, snake) => (r[camel] ?? r[snake]);
+    return {
+        id: pick('id', 'id'),
+        refType: pick('refType', 'ref_type'),
+        refId: pick('refId', 'ref_id'),
+        title: pick('title', 'title'),
+        text: pick('text', 'text'),
+        content: pick('content', 'content'),
+        contentFormat: pick('contentFormat', 'content_format'),
+        meta: pick('meta', 'meta'),
+        typeSpecificData: pick('typeSpecificData', 'type_specific_data'),
+    };
+};
+/** Single-object responses may arrive wrapped in an outer `data` envelope. */
+export const unwrapData = (res) => {
+    if (res && typeof res === 'object' && 'data' in res) {
+        const inner = res.data;
+        if (inner && typeof inner === 'object')
+            return inner;
+    }
+    return res;
+};

package/dist/src/cli/draft/create.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const create: Command.Command<"create", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | import("../../services/Resolver").Resolver | import("../../services/Lexical").Lexical, import("../../domain/errors").ValidationXml | import("../../services/Api").ApiError, {
+    readonly title: import("effect/Option").Option<string>;
+    readonly slug: import("effect/Option").Option<string>;
+    readonly category: import("effect/Option").Option<string>;
+    readonly content: import("effect/Option").Option<string>;
+    readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+    readonly summary: import("effect/Option").Option<string>;
+    readonly state: import("effect/Option").Option<"draft" | "publish">;
+    readonly tags: import("effect/Option").Option<string>;
+    readonly copyright: import("effect/Option").Option<string>;
+    readonly pin: import("effect/Option").Option<string>;
+    readonly pinOrder: import("effect/Option").Option<number>;
+    readonly related: import("effect/Option").Option<string>;
+    readonly meta: import("effect/Option").Option<string>;
+    readonly file: import("effect/Option").Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+}>;

package/dist/src/cli/draft/create.js

@@ -0,0 +1,34 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminDraftEdit } from '../../domain/admin-link';
+import { ValidationFailed } from '../../domain/errors';
+import { buildPostPayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { extractId, postWriteOptions, resolveCategoryRefs, toPostFlagInputs, } from '../post/_flags';
+import { splitDraftBody } from './_shared';
+export const create = Command.make('create', postWriteOptions, (opts) => Effect.gen(function* () {
+    const flags = toPostFlagInputs(opts);
+    const built = yield* buildPostPayload(flags);
+    const payload = yield* resolveCategoryRefs({ ...built.payload });
+    // Drafts have no publish state; it is decided at `draft publish`.
+    delete payload.isPublished;
+    const changedKeys = Object.keys(payload).filter((k) => k !== 'contentFormat');
+    if (changedKeys.length === 0) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'nothing to save: provide --file or content/meta flags',
+        }));
+    }
+    const body = splitDraftBody(payload);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/drafts', {
+        method: 'POST',
+        body: { refType: 'post', ...body },
+    });
+    const id = extractId(res);
+    yield* renderer.emitSuccess(opts.silent ? { ok: true, id } : res);
+    if (opts.open && id) {
+        yield* openAdminDraftEdit('posts', id);
+    }
+})).pipe(Command.withDescription('create a standalone post draft (not linked to any published post; publish later with `draft publish`)'));

package/dist/src/cli/draft/delete.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const del: Command.Command<"delete", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly id: string;
+    readonly force: boolean;
+}>;

package/dist/src/cli/draft/delete.js

@@ -0,0 +1,20 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const id = Args.text({ name: 'id' });
+const force = Options.boolean('force');
+export const del = Command.make('delete', { id, force }, ({ id, force }) => Effect.gen(function* () {
+    if (!force && !process.stdin.isTTY) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'refusing to delete without --force in non-TTY context',
+        }));
+    }
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    yield* api.request(`/drafts/${encodeURIComponent(id)}`, {
+        method: 'DELETE',
+    });
+    yield* renderer.emitSuccess({ deleted: id });
+})).pipe(Command.withDescription('delete a draft'));

package/dist/src/cli/draft/get.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const get: Command.Command<"get", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly id: string;
+}>;

package/dist/src/cli/draft/get.js

@@ -0,0 +1,11 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const id = Args.text({ name: 'id' });
+export const get = Command.make('get', { id }, ({ id }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/drafts/${encodeURIComponent(id)}`);
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('show a single draft by id'));

package/dist/src/cli/draft/index.d.ts

@@ -0,0 +1,54 @@
+import { Command } from '@effect/cli';
+export declare const draftCmd: Command.Command<"draft", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | import("../../services/Api").Api | import("../ai/_poll").Renderer | import("../../services/Resolver").Resolver | import("../../services/Lexical").Lexical, import("../../domain/errors").ValidationXml | import("../../services/Api").ApiError, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly category: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly summary: import("effect/Option").Option<string>;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly tags: import("effect/Option").Option<string>;
+        readonly copyright: import("effect/Option").Option<string>;
+        readonly pin: import("effect/Option").Option<string>;
+        readonly pinOrder: import("effect/Option").Option<number>;
+        readonly related: import("effect/Option").Option<string>;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+    } | {
+        readonly id: string;
+        readonly force: boolean;
+    } | {
+        readonly id: string;
+    } | {
+        readonly page: import("effect/Option").Option<number>;
+        readonly size: import("effect/Option").Option<number>;
+        readonly type: import("effect/Option").Option<"post" | "note" | "page">;
+        readonly new: boolean;
+        readonly linked: boolean;
+    } | {
+        readonly id: string;
+        readonly open: boolean;
+        readonly silent: boolean;
+    } | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly category: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly summary: import("effect/Option").Option<string>;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly tags: import("effect/Option").Option<string>;
+        readonly copyright: import("effect/Option").Option<string>;
+        readonly pin: import("effect/Option").Option<string>;
+        readonly pinOrder: import("effect/Option").Option<number>;
+        readonly related: import("effect/Option").Option<string>;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+        readonly id: string;
+    }>;
+}>;