@mx-space/cli 0.15.0 → 0.15.1

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

@@ -0,0 +1,56 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { buildPagePayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { extractId } from '../post/_flags';
+const title = Options.optional(Options.text('title'));
+const slug = Options.optional(Options.text('slug'));
+const subtitle = Options.optional(Options.text('subtitle'));
+const order = Options.optional(Options.integer('order'));
+const content = Options.optional(Options.text('content'));
+const format = Options.choice('format', ['lexical', 'markdown']).pipe(Options.optional);
+const meta = Options.optional(Options.text('meta'));
+const file = Options.optional(Options.text('file'));
+const openFlag = Options.boolean('open').pipe(Options.withDescription('After success, open the admin edit page in the default browser.'));
+const silentFlag = Options.boolean('silent').pipe(Options.withDescription('On success, emit a minimal `ok` instead of the full server response (saves output tokens). Errors still print normally.'));
+export const pageWriteOptions = {
+    title,
+    slug,
+    subtitle,
+    order,
+    content,
+    format,
+    meta,
+    file,
+    open: openFlag,
+    silent: silentFlag,
+};
+const unwrap = (value) => Option.getOrUndefined(value);
+export const toPageFlagInputs = (opts) => ({
+    title: unwrap(opts.title),
+    slug: unwrap(opts.slug),
+    subtitle: unwrap(opts.subtitle),
+    order: unwrap(opts.order),
+    content: unwrap(opts.content),
+    format: unwrap(opts.format),
+    meta: unwrap(opts.meta),
+    file: unwrap(opts.file),
+});
+export const create = Command.make('create', pageWriteOptions, (opts) => Effect.gen(function* () {
+    const flags = toPageFlagInputs(opts);
+    const built = yield* buildPagePayload(flags);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/pages', {
+        method: 'POST',
+        body: built.payload,
+    });
+    yield* renderer.emitSuccess(opts.silent ? { ok: true } : res);
+    if (opts.open) {
+        const id = extractId(res);
+        if (id)
+            yield* openAdminEdit('pages', id);
+    }
+}));

package/dist/src/cli/page/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 slugOrId: string;
+    readonly force: boolean;
+}>;

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

@@ -0,0 +1,37 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { ResourceNotFound, ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const force = Options.boolean('force');
+const resolvePageId = (api, ref) => Effect.gen(function* () {
+    if (isSnowflakeId(ref))
+        return ref;
+    const res = yield* api
+        .request(`/pages/slug/${encodeURIComponent(ref)}`)
+        .pipe(Effect.catchAll(() => Effect.succeed(null)));
+    const id = (res && res.id) ??
+        (res && res.data?.id);
+    if (!id) {
+        return yield* Effect.fail(new ResourceNotFound({
+            kind: 'page',
+            ref,
+            message: `page not found: ${ref}`,
+        }));
+    }
+    return id;
+});
+export const del = Command.make('delete', { slugOrId, force }, ({ slugOrId, 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;
+    const id = yield* resolvePageId(api, slugOrId);
+    yield* api.request(`/pages/${id}`, { method: 'DELETE' });
+    yield* renderer.emitSuccess({ deleted: id });
+}));

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

@@ -0,0 +1,19 @@
+import { Command } from '@effect/cli';
+import { ValidationXml } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Lexical } from '../../services/Lexical';
+import { Renderer } from '../../services/Renderer';
+export declare const edit: Command.Command<"edit", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | Editor | Lexical, ValidationXml | import("../../services/Api").ApiError, {
+    readonly title: import("effect/Option").Option<string>;
+    readonly slug: import("effect/Option").Option<string>;
+    readonly subtitle: import("effect/Option").Option<string>;
+    readonly order: import("effect/Option").Option<number>;
+    readonly content: import("effect/Option").Option<string>;
+    readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+    readonly meta: import("effect/Option").Option<string>;
+    readonly file: import("effect/Option").Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+    readonly slugOrId: string;
+}>;

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

@@ -0,0 +1,117 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { coerceMeta, parseEnvelope } from '../../domain/envelope';
+import { ResourceNotFound, ValidationXml } from '../../domain/errors';
+import { buildPagePayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Lexical } from '../../services/Lexical';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+import { pageWriteOptions, toPageFlagInputs } from './create';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const escapeXml = (s) => s.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const resolvePageId = (api, ref) => Effect.gen(function* () {
+    if (isSnowflakeId(ref))
+        return ref;
+    const res = yield* api
+        .request(`/pages/slug/${encodeURIComponent(ref)}`)
+        .pipe(Effect.catchAll(() => Effect.succeed(null)));
+    const id = (res && res.id) ??
+        (res && res.data?.id);
+    if (!id) {
+        return yield* Effect.fail(new ResourceNotFound({
+            kind: 'page',
+            ref,
+            message: `page not found: ${ref}`,
+        }));
+    }
+    return id;
+});
+const materializeForEditor = (ref) => Effect.gen(function* () {
+    const api = yield* Api;
+    const lexical = yield* Lexical;
+    const path = isSnowflakeId(ref)
+        ? `/pages/${ref}`
+        : `/pages/slug/${encodeURIComponent(ref)}`;
+    const page = (yield* api.request(path, {
+        query: { prefer: 'lexical' },
+    }));
+    const isLexical = page.contentFormat === 'lexical';
+    let innerXml;
+    if (isLexical && page.content) {
+        const state = JSON.parse(page.content);
+        innerXml = yield* lexical.payloadToLitexml(state);
+    }
+    else {
+        innerXml = page.content ?? '';
+    }
+    return `<mxpost>
+  <meta>
+    <title>${escapeXml(page.title ?? '')}</title>
+    <slug>${escapeXml(page.slug ?? '')}</slug>
+  </meta>
+  <content>
+${innerXml}
+  </content>
+</mxpost>
+`;
+});
+const overlayPageMeta = (payload, rawMeta) => {
+    const meta = coerceMeta(rawMeta);
+    const next = { ...payload };
+    if (meta.title !== undefined)
+        next.title = meta.title;
+    if (meta.slug !== undefined)
+        next.slug = meta.slug;
+    if (meta.subtitle !== undefined)
+        next.subtitle = meta.subtitle;
+    if (meta.order !== undefined)
+        next.order = meta.order;
+    return next;
+};
+export const edit = Command.make('edit', { slugOrId, ...pageWriteOptions }, ({ slugOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toPageFlagInputs(rest);
+    const api = yield* Api;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    // Editor round-trip path: no --file and no --content → spawn $EDITOR.
+    if (!flags.file && flags.content === undefined) {
+        const xml = yield* materializeForEditor(slugOrId);
+        const next = yield* editor.openEditor({
+            filename: `page-${slugOrId}.xml`,
+            initialContent: xml,
+        });
+        if (next.trim() === xml.trim()) {
+            yield* renderer.emitInfo('no changes');
+            return;
+        }
+        const parsed = yield* Effect.try({
+            try: () => parseEnvelope(next, 'post'),
+            catch: (err) => err instanceof ValidationXml
+                ? err
+                : new ValidationXml({ message: String(err), cause: err }),
+        });
+        const built = yield* buildPagePayload({
+            ...flags,
+            content: parsed.contentXml,
+            format: flags.format ?? 'lexical',
+        });
+        const payload = overlayPageMeta(built.payload, parsed.meta);
+        const id = yield* resolvePageId(api, slugOrId);
+        const res = yield* api.request(`/pages/${id}`, {
+            method: 'PUT',
+            body: payload,
+        });
+        yield* renderer.emitSuccess(res);
+        return;
+    }
+    // Non-interactive path: build from flags / file.
+    const built = yield* buildPagePayload(flags);
+    const id = yield* resolvePageId(api, slugOrId);
+    const res = yield* api.request(`/pages/${id}`, {
+        method: 'PUT',
+        body: built.payload,
+    });
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/page/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 slugOrId: string;
+}>;

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

@@ -0,0 +1,16 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+import { pageView } from './view';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const get = Command.make('get', { slugOrId }, ({ slugOrId }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const path = isSnowflakeId(slugOrId)
+        ? `/pages/${slugOrId}`
+        : `/pages/slug/${encodeURIComponent(slugOrId)}`;
+    const res = yield* api.request(path, { query: { prefer: 'lexical' } });
+    yield* renderer.emit(pageView, res);
+}));

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

@@ -0,0 +1,44 @@
+import { Command } from '@effect/cli';
+export declare const pageCmd: Command.Command<"page", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | import("../../services/Api").Api | import("../ai/_poll").Renderer | import("../../services/Editor").Editor | 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 subtitle: import("effect/Option").Option<string>;
+        readonly order: import("effect/Option").Option<number>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+    } | {
+        readonly slugOrId: string;
+        readonly force: boolean;
+    } | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly subtitle: import("effect/Option").Option<string>;
+        readonly order: import("effect/Option").Option<number>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+        readonly slugOrId: string;
+    } | {
+        readonly slugOrId: string;
+    } | {} | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly subtitle: import("effect/Option").Option<string>;
+        readonly order: import("effect/Option").Option<number>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+        readonly slugOrId: string;
+    }>;
+}>;

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

@@ -0,0 +1,38 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { create } from './create';
+import { del } from './delete';
+import { edit } from './edit';
+import { get } from './get';
+import { list } from './list';
+import { update } from './update';
+const help = registerCommandHelp({
+    name: 'page',
+    description: 'manage pages',
+    skillChapter: 'commands-page',
+    verbs: [
+        { name: 'list', description: 'list pages' },
+        { name: 'get', args: ['<slugOrId>'], description: 'show a single page' },
+        {
+            name: 'create',
+            args: ['[--title ...]', '[--file <path>]', '...'],
+            description: 'create a page',
+        },
+        {
+            name: 'edit',
+            args: ['<slugOrId>', '[--file <path>]', '...'],
+            description: 'edit a page via $EDITOR or flags',
+        },
+        {
+            name: 'update',
+            args: ['<slugOrId>', '[--title ...]', '...'],
+            description: 'partially update a page',
+        },
+        {
+            name: 'delete',
+            args: ['<slugOrId>', '[--force]'],
+            description: 'delete a page',
+        },
+    ],
+});
+export const pageCmd = Command.make('page').pipe(Command.withDescription(help.description), Command.withSubcommands([list, get, create, edit, update, del]));

package/dist/src/cli/page/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/page/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('/pages');
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/page/update.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const update: Command.Command<"update", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | 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 subtitle: import("effect/Option").Option<string>;
+    readonly order: import("effect/Option").Option<number>;
+    readonly content: import("effect/Option").Option<string>;
+    readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+    readonly meta: import("effect/Option").Option<string>;
+    readonly file: import("effect/Option").Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+    readonly slugOrId: string;
+}>;

package/dist/src/cli/page/update.js

@@ -0,0 +1,48 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { ResourceNotFound } from '../../domain/errors';
+import { buildPagePayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+import { pageWriteOptions, toPageFlagInputs } from './create';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const resolvePageId = (api, ref) => Effect.gen(function* () {
+    if (isSnowflakeId(ref))
+        return ref;
+    const res = yield* api
+        .request(`/pages/slug/${encodeURIComponent(ref)}`)
+        .pipe(Effect.catchAll(() => Effect.succeed(null)));
+    const id = (res && res.id) ??
+        (res && res.data?.id);
+    if (!id) {
+        return yield* Effect.fail(new ResourceNotFound({
+            kind: 'page',
+            ref,
+            message: `page not found: ${ref}`,
+        }));
+    }
+    return id;
+});
+export const update = Command.make('update', { slugOrId, ...pageWriteOptions }, ({ slugOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toPageFlagInputs(rest);
+    const built = yield* buildPagePayload(flags);
+    // PATCH: only include content if explicitly provided via flag or file.
+    const body = { ...built.payload };
+    if (flags.content === undefined && !flags.file) {
+        delete body.content;
+        delete body.text;
+        delete body.contentFormat;
+    }
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolvePageId(api, slugOrId);
+    const res = yield* api.request(`/pages/${id}`, {
+        method: 'PATCH',
+        body,
+    });
+    yield* renderer.emitSuccess(rest.silent ? { ok: true } : res);
+    if (rest.open)
+        yield* openAdminEdit('pages', id);
+}));

package/dist/src/cli/page/view.d.ts

@@ -0,0 +1,2 @@
+import type { View } from '../../services/Renderer/view';
+export declare const pageView: View<unknown>;

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

@@ -0,0 +1,79 @@
+import { asRecord, contentFormat, first, firstString, pickArticleTranslationMeta, renderContent, unwrapDocument, } from '../../services/Renderer/content';
+import { frontmatter, renderEnvelope, renderMetadataBlock } from '../render';
+const normalize = (data) => asRecord(unwrapDocument(data));
+const collectFields = (doc, articleMeta) => {
+    const meta = articleMeta ?? {};
+    const fields = [
+        ['id', first(doc, 'id')],
+        ['slug', first(doc, 'slug')],
+        ['subtitle', first(doc, 'subtitle')],
+        ['order', first(doc, 'order')],
+        ['created_at', first(doc, 'created_at', 'createdAt')],
+        ['modified_at', first(doc, 'modified_at', 'modifiedAt')],
+        [
+            'source_lang',
+            first(doc, 'source_lang', 'sourceLang') ??
+                first(meta, 'source_lang', 'sourceLang'),
+        ],
+        [
+            'translated',
+            first(doc, 'is_translated', 'isTranslated') ??
+                first(meta, 'is_translated', 'isTranslated'),
+        ],
+    ];
+    return fields.filter(([key, value]) => value !== undefined &&
+        value !== null &&
+        value !== '' &&
+        !(key === 'translated' && value === false));
+};
+const collectEnvelopeMeta = (doc) => [
+    ['title', first(doc, 'title')],
+    ['slug', first(doc, 'slug')],
+    ['subtitle', first(doc, 'subtitle')],
+    ['order', first(doc, 'order')],
+    ['format', contentFormat(doc)],
+];
+const pickSummary = (doc) => {
+    const summary = firstString(doc, 'summary', 'subtitle');
+    const subtitle = firstString(doc, 'subtitle');
+    return summary && summary !== subtitle ? summary : undefined;
+};
+export const pageView = {
+    kind: 'page',
+    modes: new Set(['readable', 'llm', 'xml']),
+    readable: (data, ctx) => {
+        const doc = normalize(data);
+        const articleMeta = pickArticleTranslationMeta(data, first(doc, 'id'));
+        const content = renderContent(doc);
+        const title = firstString(doc, 'title');
+        return renderMetadataBlock({
+            title: title || undefined,
+            kind: 'page',
+            fields: collectFields(doc, articleMeta),
+            summary: pickSummary(doc),
+            body: content.body || undefined,
+            bodyFormat: content.format,
+        }, ctx);
+    },
+    llm: (data) => {
+        const doc = normalize(data);
+        const articleMeta = pickArticleTranslationMeta(data, first(doc, 'id'));
+        const content = renderContent(doc, true);
+        const title = firstString(doc, 'title');
+        const fm = frontmatter({
+            title: title || undefined,
+            fields: collectFields(doc, articleMeta),
+            summary: pickSummary(doc),
+        });
+        return content.body ? `${fm}\n\n${content.body}` : fm;
+    },
+    xml: (data) => {
+        const doc = normalize(data);
+        const content = renderContent(doc);
+        return renderEnvelope({
+            root: 'mxpage',
+            meta: collectEnvelopeMeta(doc),
+            content: content.body,
+        });
+    },
+};

package/dist/src/cli/post/_flags.d.ts

@@ -0,0 +1,66 @@
+import { Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import type { Generic, ValidationFailed } from '../../domain/errors';
+import type { ContentFormat, PostFlagInputs } from '../../domain/payload';
+import { Resolver } from '../../services/Resolver';
+export declare const title: Options.Options<Option.Option<string>>;
+export declare const slug: Options.Options<Option.Option<string>>;
+export declare const category: Options.Options<Option.Option<string>>;
+export declare const content: Options.Options<Option.Option<string>>;
+export declare const summary: Options.Options<Option.Option<string>>;
+export declare const file: Options.Options<Option.Option<string>>;
+export declare const meta: Options.Options<Option.Option<string>>;
+export declare const pin: Options.Options<Option.Option<string>>;
+export declare const format: Options.Options<Option.Option<"markdown" | "lexical">>;
+export declare const state: Options.Options<Option.Option<"draft" | "publish">>;
+export declare const tags: Options.Options<Option.Option<string>>;
+export declare const related: Options.Options<Option.Option<string>>;
+export declare const pinOrder: Options.Options<Option.Option<number>>;
+export declare const copyright: Options.Options<Option.Option<string>>;
+export declare const openFlag: Options.Options<boolean>;
+export declare const silentFlag: Options.Options<boolean>;
+export declare const postWriteOptions: {
+    title: Options.Options<Option.Option<string>>;
+    slug: Options.Options<Option.Option<string>>;
+    category: Options.Options<Option.Option<string>>;
+    content: Options.Options<Option.Option<string>>;
+    format: Options.Options<Option.Option<"markdown" | "lexical">>;
+    summary: Options.Options<Option.Option<string>>;
+    state: Options.Options<Option.Option<"draft" | "publish">>;
+    tags: Options.Options<Option.Option<string>>;
+    copyright: Options.Options<Option.Option<string>>;
+    pin: Options.Options<Option.Option<string>>;
+    pinOrder: Options.Options<Option.Option<number>>;
+    related: Options.Options<Option.Option<string>>;
+    meta: Options.Options<Option.Option<string>>;
+    file: Options.Options<Option.Option<string>>;
+    open: Options.Options<boolean>;
+    silent: Options.Options<boolean>;
+};
+export type PostWriteOptionsParsed = {
+    readonly title: Option.Option<string>;
+    readonly slug: Option.Option<string>;
+    readonly category: Option.Option<string>;
+    readonly content: Option.Option<string>;
+    readonly format: Option.Option<ContentFormat>;
+    readonly summary: Option.Option<string>;
+    readonly state: Option.Option<'publish' | 'draft'>;
+    readonly tags: Option.Option<string>;
+    readonly copyright: Option.Option<string>;
+    readonly pin: Option.Option<string>;
+    readonly pinOrder: Option.Option<number>;
+    readonly related: Option.Option<string>;
+    readonly meta: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+};
+/** Resolve `__categoryName` placeholder (set by `buildPostPayload`) → `categoryId`. */
+export declare const resolveCategoryRefs: (payload: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, ValidationFailed | Generic, Resolver>;
+export declare const toPostFlagInputs: (opts: PostWriteOptionsParsed) => PostFlagInputs;
+/**
+ * Extract the id from a server response — handles both `id` and `_id`,
+ * and unwraps the outer `data` envelope mx-core wraps single-object
+ * responses with (so `--open` works after `post create`).
+ */
+export declare const extractId: (res: unknown) => string | undefined;