@mx-space/cli 0.14.2 → 0.15.1

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

@@ -0,0 +1,114 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { coerceMeta, parseEnvelope } from '../../domain/envelope';
+import { ValidationXml } from '../../domain/errors';
+import { buildNotePayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Lexical } from '../../services/Lexical';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { noteWriteOptions, resolveTopicRefs, toNoteFlagInputs } from './_flags';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const esc = (s) => s.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const materializeForEditor = (slugOrId) => Effect.gen(function* () {
+    const api = yield* Api;
+    const resolver = yield* Resolver;
+    const lexical = yield* Lexical;
+    const id = yield* resolver.resolveNoteId(slugOrId);
+    const note = (yield* api.request(`/notes/${id}`, {
+        query: { prefer: 'lexical' },
+    }));
+    let inner;
+    if (note.contentFormat === 'lexical' && note.content) {
+        const state = JSON.parse(note.content);
+        inner = yield* lexical.payloadToLitexml(state);
+    }
+    else {
+        inner = note.content ?? '';
+    }
+    return `<mxnote>
+  <meta>
+    <title>${esc(note.title ?? '')}</title>
+    ${note.slug ? `<slug>${esc(note.slug)}</slug>` : ''}
+    <state>${note.isPublished ? 'publish' : 'draft'}</state>
+    ${note.mood ? `<mood>${esc(note.mood)}</mood>` : ''}
+    ${note.weather ? `<weather>${esc(note.weather)}</weather>` : ''}
+  </meta>
+  <content>
+${inner}
+  </content>
+</mxnote>
+`;
+});
+const applyNoteEnvelopeMeta = (payload, rawMeta) => {
+    const next = { ...payload };
+    const meta = coerceMeta(rawMeta);
+    if (meta.title !== undefined)
+        next.title = meta.title;
+    if (meta.slug !== undefined)
+        next.slug = meta.slug;
+    if (meta.topic !== undefined)
+        next.__topicName = meta.topic;
+    if (meta.state !== undefined)
+        next.isPublished = meta.state === 'publish';
+    if (meta.mood !== undefined)
+        next.mood = meta.mood;
+    if (meta.weather !== undefined)
+        next.weather = meta.weather;
+    if (meta.publicAt !== undefined)
+        next.publicAt = meta.publicAt;
+    if (meta.password !== undefined)
+        next.password = meta.password;
+    if (meta.bookmark !== undefined)
+        next.bookmark = meta.bookmark;
+    if (meta.location !== undefined)
+        next.location = meta.location;
+    return next;
+};
+export const edit = Command.make('edit', { slugOrId, ...noteWriteOptions }, ({ slugOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toNoteFlagInputs(rest);
+    const api = yield* Api;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    if (!flags.file && flags.content === undefined) {
+        const xml = yield* materializeForEditor(slugOrId);
+        const next = yield* editor.openEditor({
+            filename: `note-${slugOrId}.xml`,
+            initialContent: xml,
+        });
+        if (next.trim() === xml.trim()) {
+            yield* renderer.emitInfo('no changes');
+            return;
+        }
+        const parsed = yield* Effect.try({
+            try: () => parseEnvelope(next, 'note'),
+            catch: (err) => err instanceof ValidationXml
+                ? err
+                : new ValidationXml({ message: String(err), cause: err }),
+        });
+        const built = yield* buildNotePayload({
+            ...flags,
+            content: parsed.contentXml,
+            format: flags.format ?? 'lexical',
+        });
+        const payload = applyNoteEnvelopeMeta(built.payload, parsed.meta);
+        const resolved = yield* resolveTopicRefs(payload);
+        const id = yield* resolver.resolveNoteId(slugOrId);
+        const res = yield* api.request(`/notes/${id}`, {
+            method: 'PUT',
+            body: resolved,
+        });
+        yield* renderer.emitSuccess(res);
+        return;
+    }
+    const built = yield* buildNotePayload(flags);
+    const resolved = yield* resolveTopicRefs(built.payload);
+    const id = yield* resolver.resolveNoteId(slugOrId);
+    const res = yield* api.request(`/notes/${id}`, {
+        method: 'PUT',
+        body: resolved,
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('edit a note via $EDITOR or flags'));

package/dist/src/cli/note/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/note/get.js

@@ -0,0 +1,29 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+import { noteView } 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;
+    if (isSnowflakeId(slugOrId)) {
+        const res = yield* api.request(`/notes/${slugOrId}`, {
+            query: { prefer: 'lexical' },
+        });
+        yield* renderer.emit(noteView, res);
+        return;
+    }
+    if (/^\d+$/.test(slugOrId)) {
+        const res = yield* api.request(`/notes/nid/${slugOrId}`, {
+            query: { single: '1', prefer: 'lexical' },
+        });
+        yield* renderer.emit(noteView, res);
+        return;
+    }
+    return yield* Effect.fail(new ValidationFailed({
+        message: `invalid note reference: ${slugOrId} (use snowflake id or numeric nid)`,
+    }));
+})).pipe(Command.withDescription('get a note by snowflake id or numeric nid'));

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

@@ -0,0 +1,77 @@
+import { Command } from '@effect/cli';
+export declare const noteCmd: Command.Command<"note", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | import("../../services/Api").Api | import("../ai/_poll").Renderer | import("../../services/Resolver").Resolver | 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 topic: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly mood: import("effect/Option").Option<string>;
+        readonly weather: import("effect/Option").Option<string>;
+        readonly publicAt: import("effect/Option").Option<string>;
+        readonly password: import("effect/Option").Option<string>;
+        readonly bookmark: import("effect/Option").Option<string>;
+        readonly coords: import("effect/Option").Option<string>;
+        readonly location: import("effect/Option").Option<string>;
+        readonly images: 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 slugOrId: string;
+        readonly force: boolean;
+    } | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly topic: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly mood: import("effect/Option").Option<string>;
+        readonly weather: import("effect/Option").Option<string>;
+        readonly publicAt: import("effect/Option").Option<string>;
+        readonly password: import("effect/Option").Option<string>;
+        readonly bookmark: import("effect/Option").Option<string>;
+        readonly coords: import("effect/Option").Option<string>;
+        readonly location: import("effect/Option").Option<string>;
+        readonly images: 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 slugOrId: string;
+    } | {
+        readonly slugOrId: string;
+    } | {
+        readonly page: import("effect/Option").Option<number>;
+        readonly size: import("effect/Option").Option<number>;
+        readonly state: import("effect/Option").Option<string>;
+        readonly sort: import("effect/Option").Option<string>;
+    } | {
+        readonly slugOrId: string;
+    } | {
+        readonly slugOrId: string;
+    } | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly topic: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly mood: import("effect/Option").Option<string>;
+        readonly weather: import("effect/Option").Option<string>;
+        readonly publicAt: import("effect/Option").Option<string>;
+        readonly password: import("effect/Option").Option<string>;
+        readonly bookmark: import("effect/Option").Option<string>;
+        readonly coords: import("effect/Option").Option<string>;
+        readonly location: import("effect/Option").Option<string>;
+        readonly images: 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 slugOrId: string;
+    }>;
+}>;

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

@@ -0,0 +1,63 @@
+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 { publish } from './publish';
+import { unpublish } from './unpublish';
+import { update } from './update';
+const help = registerCommandHelp({
+    name: 'note',
+    description: 'manage notes',
+    skillChapter: 'commands-note',
+    verbs: [
+        {
+            name: 'list',
+            args: ['[--page <n>]', '[--size <n>]', '[--state <s>]', '[--sort <s>]'],
+            description: 'list notes',
+        },
+        {
+            name: 'get',
+            args: ['<slugOrId>'],
+            description: 'get a note by snowflake id or numeric nid',
+        },
+        {
+            name: 'create',
+            args: ['[--title ...]', '[--file <path>]', '...'],
+            description: 'create a note',
+        },
+        {
+            name: 'edit',
+            args: ['<slugOrId>', '[--file <path>]', '...'],
+            description: 'edit a note via $EDITOR or flags',
+        },
+        {
+            name: 'update',
+            args: ['<slugOrId>', '[--title ...]', '...'],
+            description: 'partially update a note',
+        },
+        {
+            name: 'delete',
+            args: ['<slugOrId>', '[--force]'],
+            description: 'delete a note',
+        },
+        { name: 'publish', args: ['<slugOrId>'], description: 'publish a note' },
+        {
+            name: 'unpublish',
+            args: ['<slugOrId>'],
+            description: 'unpublish a note',
+        },
+    ],
+});
+export const noteCmd = Command.make('note').pipe(Command.withDescription(help.description), Command.withSubcommands([
+    list,
+    get,
+    create,
+    edit,
+    update,
+    del,
+    publish,
+    unpublish,
+]));

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

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const list: Command.Command<"list", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly page: Option.Option<number>;
+    readonly size: Option.Option<number>;
+    readonly state: Option.Option<string>;
+    readonly sort: Option.Option<string>;
+}>;

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

@@ -0,0 +1,22 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { noteListView } from './view';
+const page = Options.integer('page').pipe(Options.optional);
+const size = Options.integer('size').pipe(Options.optional);
+const state = Options.text('state').pipe(Options.optional);
+const sort = Options.text('sort').pipe(Options.optional);
+const unwrap = (value) => Option.getOrUndefined(value);
+export const list = Command.make('list', { page, size, state, sort }, ({ page, size, sort }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/notes', {
+        query: {
+            page: unwrap(page),
+            size: unwrap(size),
+            sortBy: unwrap(sort),
+        },
+    });
+    yield* renderer.emit(noteListView, res);
+})).pipe(Command.withDescription('list notes'));

package/dist/src/cli/note/publish.d.ts

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

package/dist/src/cli/note/publish.js

@@ -0,0 +1,17 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const publish = Command.make('publish', { slugOrId }, ({ slugOrId }) => Effect.gen(function* () {
+    const resolver = yield* Resolver;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolver.resolveNoteId(slugOrId);
+    const res = yield* api.request(`/notes/${id}/publish`, {
+        method: 'PATCH',
+        body: { isPublished: true },
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('publish a note'));

package/dist/src/cli/note/unpublish.d.ts

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

package/dist/src/cli/note/unpublish.js

@@ -0,0 +1,17 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const unpublish = Command.make('unpublish', { slugOrId }, ({ slugOrId }) => Effect.gen(function* () {
+    const resolver = yield* Resolver;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolver.resolveNoteId(slugOrId);
+    const res = yield* api.request(`/notes/${id}/publish`, {
+        method: 'PATCH',
+        body: { isPublished: false },
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('unpublish a note'));

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

@@ -0,0 +1,25 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const update: Command.Command<"update", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | 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 topic: import("effect/Option").Option<string>;
+    readonly content: import("effect/Option").Option<string>;
+    readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+    readonly state: import("effect/Option").Option<"draft" | "publish">;
+    readonly mood: import("effect/Option").Option<string>;
+    readonly weather: import("effect/Option").Option<string>;
+    readonly publicAt: import("effect/Option").Option<string>;
+    readonly password: import("effect/Option").Option<string>;
+    readonly bookmark: import("effect/Option").Option<string>;
+    readonly coords: import("effect/Option").Option<string>;
+    readonly location: import("effect/Option").Option<string>;
+    readonly images: 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 slugOrId: string;
+}>;

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

@@ -0,0 +1,36 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { buildNotePayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { noteWriteOptions, resolveTopicRefs, toNoteFlagInputs } from './_flags';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const update = Command.make('update', { slugOrId, ...noteWriteOptions }, ({ slugOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toNoteFlagInputs(rest);
+    const built = yield* buildNotePayload(flags);
+    const payload = { ...built.payload };
+    if (flags.content === undefined && !flags.file) {
+        delete payload.content;
+        delete payload.text;
+        delete payload.contentFormat;
+    }
+    // Envelope <state> must not flip publish state on update; only the
+    // explicit --state flag (or publish/unpublish) changes it. See the same
+    // guard in post/update.ts.
+    if (flags.state === undefined)
+        delete payload.isPublished;
+    const resolved = yield* resolveTopicRefs(payload);
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolveNoteId(slugOrId);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/notes/${id}`, {
+        method: 'PATCH',
+        body: resolved,
+    });
+    yield* renderer.emitSuccess(rest.silent ? { ok: true } : res);
+    if (rest.open)
+        yield* openAdminEdit('notes', id);
+})).pipe(Command.withDescription('partially update a note'));

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

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

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

@@ -0,0 +1,162 @@
+import { asRecord, contentFormat, first, firstString, formatScalar, pickArticleTranslationMeta, publishState, relationLabel, relationSlugOrLabel, renderContent, unwrapDocument, } from '../../services/Renderer/content';
+import { tryFormatTimestamp } from '../../services/Renderer/datetime';
+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')],
+        ['nid', first(doc, 'nid')],
+        ['state', publishState(doc)],
+        ['topic', relationLabel(first(doc, 'topic'))],
+        ['mood', first(doc, 'mood')],
+        ['weather', first(doc, 'weather')],
+        ['public_at', first(doc, 'public_at', 'publicAt')],
+        ['bookmark', first(doc, 'bookmark')],
+        ['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')],
+    ['topic', relationSlugOrLabel(first(doc, 'topic'))],
+    ['state', publishState(doc) === 'published' ? 'publish' : 'draft'],
+    ['mood', first(doc, 'mood')],
+    ['weather', first(doc, 'weather')],
+    ['publicAt', first(doc, 'public_at', 'publicAt')],
+    ['bookmark', first(doc, 'bookmark')],
+    ['location', first(doc, 'location')],
+    ['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 noteView = {
+    kind: 'note',
+    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: 'note',
+            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: 'mxnote',
+            meta: collectEnvelopeMeta(doc),
+            content: content.body,
+        });
+    },
+};
+const collectListItemFields = (doc, articleMeta) => {
+    const meta = articleMeta ?? {};
+    return [
+        ['id', first(doc, 'id')],
+        ['nid', first(doc, 'nid')],
+        ['title', first(doc, 'title')],
+        ['slug', first(doc, 'slug')],
+        ['state', publishState(doc)],
+        ['topic', relationLabel(first(doc, 'topic'))],
+        ['mood', first(doc, 'mood')],
+        ['weather', first(doc, 'weather')],
+        ['bookmark', first(doc, 'bookmark')],
+        ['summary', first(doc, 'summary')],
+        ['public_at', first(doc, 'public_at', 'publicAt')],
+        ['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'),
+        ],
+    ];
+};
+const renderNoteListReadable = (data) => {
+    const payload = asRecord(data);
+    const rows = Array.isArray(payload.data)
+        ? payload.data
+        : Array.isArray(data)
+            ? data
+            : [];
+    const meta = asRecord(first(payload, 'meta'));
+    const pagination = asRecord(first(meta, 'pagination'));
+    const lines = ['notes'];
+    if (rows.length > 0)
+        lines.push(`count: ${rows.length}`);
+    else
+        lines.push('count: 0');
+    const page = first(pagination, 'page', 'currentPage');
+    const size = first(pagination, 'size', 'pageSize');
+    const total = first(pagination, 'total', 'totalCount', 'total_count');
+    if (page !== undefined)
+        lines.push(`page: ${formatScalar(page)}`);
+    if (size !== undefined)
+        lines.push(`size: ${formatScalar(size)}`);
+    if (total !== undefined)
+        lines.push(`total: ${formatScalar(total)}`);
+    rows.forEach((row, index) => {
+        const doc = asRecord(row);
+        const articleMeta = pickArticleTranslationMeta(data, first(doc, 'id'));
+        lines.push('', `note ${index + 1}:`);
+        const fields = collectListItemFields(doc, articleMeta);
+        for (const [key, value] of fields) {
+            if (value === undefined || value === null || value === '')
+                continue;
+            if (key === 'translated' && value === false)
+                continue;
+            const rendered = tryFormatTimestamp(value, { style: 'rel' }) ?? formatScalar(value);
+            lines.push(`${key}: ${rendered}`);
+        }
+    });
+    return lines.join('\n');
+};
+export const noteListView = {
+    kind: 'note-list',
+    modes: new Set(['readable', 'llm']),
+    readable: (data) => renderNoteListReadable(data),
+};

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

@@ -0,0 +1,41 @@
+import { Command, Options } from '@effect/cli';
+import { Option } from 'effect';
+import type { PageFlagInputs } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const pageWriteOptions: {
+    title: Options.Options<Option.Option<string>>;
+    slug: Options.Options<Option.Option<string>>;
+    subtitle: Options.Options<Option.Option<string>>;
+    order: Options.Options<Option.Option<number>>;
+    content: Options.Options<Option.Option<string>>;
+    format: Options.Options<Option.Option<"markdown" | "lexical">>;
+    meta: Options.Options<Option.Option<string>>;
+    file: Options.Options<Option.Option<string>>;
+    open: Options.Options<boolean>;
+    silent: Options.Options<boolean>;
+};
+export declare const toPageFlagInputs: (opts: {
+    readonly title: Option.Option<string>;
+    readonly slug: Option.Option<string>;
+    readonly subtitle: Option.Option<string>;
+    readonly order: Option.Option<number>;
+    readonly content: Option.Option<string>;
+    readonly format: Option.Option<"lexical" | "markdown">;
+    readonly meta: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+}) => PageFlagInputs;
+export declare const create: Command.Command<"create", 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: Option.Option<string>;
+    readonly slug: Option.Option<string>;
+    readonly subtitle: Option.Option<string>;
+    readonly order: Option.Option<number>;
+    readonly content: Option.Option<string>;
+    readonly format: Option.Option<"markdown" | "lexical">;
+    readonly meta: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+}>;