@mx-space/cli 0.15.0 → 0.15.1

package/dist/test/services/Renderer.test.js

@@ -0,0 +1,538 @@
+import { it } from '@effect/vitest';
+import { Effect } from 'effect';
+import { afterEach, beforeEach, describe, expect, vi } from 'vitest';
+import { AuthDenied, Generic, ValidationFailed, WriteRequiresExplicit, } from '../../src/domain/errors';
+import { noteView } from '../../src/cli/note/view';
+import { pageView } from '../../src/cli/page/view';
+import { postListView, postView } from '../../src/cli/post/view';
+import { Lexical } from '../../src/services/Lexical';
+import { currentOutputOptions, defaultOutputOptions, renderReadableGeneric, Renderer, } from '../../src/services/Renderer';
+const viewCtx = { color: false, verbose: false };
+let stdoutLines;
+let stderrLines;
+let stdoutSpy;
+let stderrSpy;
+beforeEach(() => {
+    stdoutLines = [];
+    stderrLines = [];
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+        stdoutLines.push(String(chunk));
+        return true;
+    });
+    stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+        stderrLines.push(String(chunk));
+        return true;
+    });
+});
+afterEach(() => {
+    stdoutSpy.mockRestore();
+    stderrSpy.mockRestore();
+});
+const withOpts = (opts, effect) => Effect.locally(effect, currentOutputOptions, {
+    ...defaultOutputOptions,
+    ...opts,
+});
+describe('Renderer — emitSuccess', () => {
+    it.effect('writes JSON envelope under --json', () => withOpts({ json: true }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitSuccess({ hello: 'world' });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines).toHaveLength(1);
+        const parsed = JSON.parse(stdoutLines[0]);
+        expect(parsed).toEqual({ ok: true, data: { hello: 'world' } });
+    })), Effect.provide(Renderer.Default)));
+    it.effect('writes pretty JSON for objects under pretty-json', () => withOpts({ json: false, output: 'pretty-json' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitSuccess({ ok: 1 });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines.join('')).toBe(`${JSON.stringify({ ok: 1 }, null, 2)}\n`);
+    })), Effect.provide(Renderer.Default)));
+    it.effect('writes readable key: value lines by default', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitSuccess({
+            current: '0.3.1',
+            latest: '0.3.1',
+            channel: 'stable',
+            up_to_date: true,
+        });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const out = stdoutLines.join('');
+        expect(out).toBe('current: 0.3.1\nlatest: 0.3.1\nchannel: stable\nup_to_date: true\n');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('renders nested objects with indentation under readable', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitSuccess({
+            user: { name: 'Innei', email: 'i@innei.in' },
+            api_url: 'https://mx.innei.in',
+        });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const out = stdoutLines.join('');
+        expect(out).toContain('user:');
+        expect(out).toContain('  name: Innei');
+        expect(out).toContain('  email: i@innei.in');
+        expect(out).toContain('api_url: https://mx.innei.in');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('writes string data verbatim', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitSuccess('hello');
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines.join('')).toBe('hello\n');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('does not emit null or undefined success payloads', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitSuccess(null);
+        yield* renderer.emitSuccess(undefined);
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines).toHaveLength(0);
+    })), Effect.provide(Renderer.Default)));
+});
+describe('Renderer — emitInfo / emitWarn', () => {
+    it.effect('emitInfo writes to stderr by default', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitInfo('hello');
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stderrLines.join('')).toBe('hello\n');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('emitInfo is suppressed under --quiet', () => withOpts({ quiet: true }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitInfo('hello');
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stderrLines).toHaveLength(0);
+    })), Effect.provide(Renderer.Default)));
+    it.effect('emitInfo is suppressed under --json', () => withOpts({ json: true }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitInfo('hello');
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stderrLines).toHaveLength(0);
+    })), Effect.provide(Renderer.Default)));
+    it.effect('emitWarn writes to stderr by default', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitWarn('careful');
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stderrLines.join('')).toContain('careful');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('emitWarn is suppressed under --json', () => withOpts({ json: true }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitWarn('careful');
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stderrLines).toHaveLength(0);
+    })), Effect.provide(Renderer.Default)));
+});
+describe('Renderer — emitError', () => {
+    it.effect('serializes the write_requires_explicit envelope (legacy shape)', () => withOpts({ json: true }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitError(new WriteRequiresExplicit({
+            message: 'writing to production requires explicit acknowledgement',
+            hint: 'pass --profile prod to confirm',
+            profile: 'prod',
+            apiUrl: 'https://blog.example.com',
+        }));
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stderrLines).toHaveLength(0);
+        expect(stdoutLines).toHaveLength(1);
+        const parsed = JSON.parse(stdoutLines[0]);
+        expect(parsed).toMatchObject({
+            ok: false,
+            error: 'profile.write_requires_explicit',
+            profile: 'prod',
+            api_url: 'https://blog.example.com',
+            hint: 'pass --profile prod to confirm',
+        });
+    })), Effect.provide(Renderer.Default)));
+    it.effect('writes a terse line to stderr (no JSON) when not --json', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitError(new WriteRequiresExplicit({
+            message: 'writing to production requires explicit acknowledgement',
+            hint: 'pass --profile prod to confirm',
+            profile: 'prod',
+            apiUrl: 'https://blog.example.com',
+        }));
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines).toHaveLength(0);
+        expect(stderrLines.length).toBeGreaterThan(0);
+        const combined = stderrLines.join('');
+        expect(combined).toContain('writing to production requires explicit acknowledgement');
+        expect(() => JSON.parse(combined)).toThrow();
+    })), Effect.provide(Renderer.Default)));
+    it.effect('emits ValidationFailed envelope under --json', () => withOpts({ json: true }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitError(new ValidationFailed({ message: 'bad input', hint: 'fix it' }));
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines).toHaveLength(1);
+        const parsed = JSON.parse(stdoutLines[0]);
+        expect(parsed).toEqual({
+            ok: false,
+            code: 'validation.failed',
+            message: 'bad input',
+            hint: 'fix it',
+        });
+    })), Effect.provide(Renderer.Default)));
+    it.effect('formats object details, issue details, primitive details, and hints', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitError(new Generic({ message: '', details: { a: 1 }, hint: 'inspect' }));
+        yield* renderer.emitError(new ValidationFailed({
+            message: 'bad shape',
+            details: {
+                issues: [
+                    {
+                        path: ['meta', 'title'],
+                        message: 'required',
+                        line: 3,
+                        suggestions: ['name'],
+                    },
+                ],
+            },
+        }));
+        yield* renderer.emitError(new AuthDenied({ message: 'denied', details: 'plain' }));
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const err = stderrLines.join('');
+        expect(err).toContain('mxs error');
+        expect(err).toContain('{"a":1}');
+        expect(err).toContain('hint: inspect');
+        expect(err).toContain('meta.title: required (line 3)');
+        expect(err).toContain('did you mean name');
+        expect(err).toContain('plain');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('formats array-form details in readable mode', () => withOpts({}, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emitError(new Generic({
+            message: 'array details',
+            details: [
+                { path: ['payload', 'title'], message: 'required' },
+                'plain detail',
+            ],
+        }));
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const err = stderrLines.join('');
+        expect(err).toContain('payload.title: required');
+        expect(err).toContain('plain detail');
+    })), Effect.provide(Renderer.Default)));
+});
+describe('Renderer — emit(postListView)', () => {
+    it.effect('emits pretty JSON under --output pretty-json', () => withOpts({ output: 'pretty-json' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(postListView, {
+            data: [{ id: '1', title: 'a', slug: 'a' }],
+            meta: { pagination: { page: 1, size: 10, total: 1 } },
+        });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines.join('')).toContain('"data"');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('renders readable rows under --output readable', () => withOpts({ output: 'readable' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(postListView, {
+            data: [
+                {
+                    id: '1',
+                    title: 'Translated Title',
+                    slug: 'translated-title',
+                    isTranslated: true,
+                    sourceLang: 'zh-CN',
+                    isPublished: true,
+                    category: { name: 'Tech' },
+                    tags: ['cli', 'llm'],
+                    summary: 'Short summary.',
+                },
+            ],
+            meta: { pagination: { page: 1, size: 10, total: 1 } },
+        });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const out = stdoutLines.join('');
+        expect(out).toContain('posts');
+        expect(out).toContain('count: 1');
+        expect(out).toContain('page: 1');
+        expect(out).toContain('post 1:');
+        expect(out).toContain('title: Translated Title');
+        expect(out).toContain('category: Tech');
+        expect(out).toContain('tags: cli, llm');
+        expect(out).toContain('translated: true');
+        expect(out).not.toContain('content:');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('renders empty arrays and rejects envelope mode for post list', () => withOpts({ output: 'llm' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(postListView, []);
+    })).pipe(Effect.zipRight(withOpts({ output: 'xml' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(postListView, { data: [] });
+    }))), Effect.tap(() => Effect.sync(() => {
+        expect(stdoutLines.join('')).toContain('count: 0');
+        expect(stderrLines.join('')).toContain('unsupported --output value for post-list: xml');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('emits colored unsupported-mode errors when stderr is a TTY', () => withOpts({ output: 'xml' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        const prevIsTTY = process.stderr.isTTY;
+        Object.defineProperty(process.stderr, 'isTTY', {
+            value: true,
+            configurable: true,
+        });
+        try {
+            yield* renderer.emit(postListView, { data: [] });
+        }
+        finally {
+            Object.defineProperty(process.stderr, 'isTTY', {
+                value: prevIsTTY,
+                configurable: true,
+            });
+        }
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        expect(stderrLines.join('')).toContain('\x1B[31m');
+        expect(stderrLines.join('')).toContain('unsupported --output value for post-list: xml');
+    })), Effect.provide(Renderer.Default)));
+});
+describe('Renderer — emit(postView/noteView/pageView)', () => {
+    it.effect('renders readable post metadata under --output readable', () => withOpts({ output: 'readable' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(postView, {
+            id: '1',
+            title: 'Readable Post',
+            slug: 'readable-post',
+            isPublished: true,
+            category: { name: 'Tech', slug: 'tech' },
+            tags: ['cli', 'ai'],
+            summary: 'Short summary.',
+            contentFormat: 'markdown',
+            content: 'hello',
+        });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const out = stdoutLines.join('');
+        expect(out).toContain('Readable Post');
+        expect(out).toContain('state');
+        expect(out).toContain('published');
+        expect(out).toContain('category');
+        expect(out).toContain('Tech');
+        expect(out).toContain('tags');
+        expect(out).toContain('cli, ai');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('renders note envelope under --output envelope', () => withOpts({ output: 'xml' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(noteView, {
+            title: 'Daily Note',
+            slug: 'daily-note',
+            is_published: false,
+            topic: { slug: 'life', name: 'Life' },
+            mood: 'calm',
+            bookmark: true,
+            content_format: 'markdown',
+            content: '# Body',
+        });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const out = stdoutLines.join('');
+        expect(out).toContain('<mxnote>');
+        expect(out).toContain('<topic>life</topic>');
+        expect(out).toContain('<state>draft</state>');
+        expect(out).toContain('<format>markdown</format>');
+        expect(out).toContain('# Body');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('renders Lexical content as styled ANSI in readable mode', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.litexmlToPayload('<p>Hello world.</p>');
+        const content = JSON.stringify(state);
+        yield* withOpts({ output: 'readable' }, Effect.gen(function* () {
+            const renderer = yield* Renderer;
+            yield* renderer.emit(postView, {
+                id: '1',
+                title: 'Readable Post',
+                slug: 'readable-post',
+                isPublished: true,
+                category: { name: 'Tech', slug: 'tech' },
+                tags: ['cli', 'ai'],
+                summary: 'Short summary.',
+                contentFormat: 'lexical',
+                content,
+            });
+        }));
+        const out = stdoutLines.join('');
+        expect(out).toContain('Hello world.');
+        expect(out).not.toContain('<p>');
+        expect(out).not.toContain('"root"');
+    }).pipe(Effect.provide(Renderer.Default), Effect.provide(Lexical.Default)));
+    it.effect('renders post tags as child elements in envelope mode', () => withOpts({ output: 'xml' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(postView, {
+            title: 'Tagged Post',
+            slug: 'tagged-post',
+            isPublished: true,
+            tags: ['cli', 'ai'],
+            contentFormat: 'markdown',
+            content: 'Body',
+        });
+    })).pipe(Effect.tap(() => Effect.sync(() => {
+        const out = stdoutLines.join('');
+        expect(out).toContain('<tags>');
+        expect(out).toContain('<tag>cli</tag>');
+        expect(out).toContain('<tag>ai</tag>');
+        expect(out).not.toContain('<tags>cli,ai</tags>');
+    })), Effect.provide(Renderer.Default)));
+    it.effect('unwraps { data } documents and rejects unsupported output modes', () => withOpts({ output: 'readable' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(pageView, {
+            data: {
+                id: 'pg1',
+                title: 'Page',
+                slug: 'page',
+                subtitle: 'Sub',
+                order: 2,
+                createdAt: new Date('2026-01-01T00:00:00Z'),
+                isTranslated: false,
+                content_format: 'html',
+                text: 'Fallback text',
+            },
+        });
+    })).pipe(Effect.zipRight(withOpts({ output: 'table' }, Effect.gen(function* () {
+        const renderer = yield* Renderer;
+        yield* renderer.emit(postView, { title: 'x' });
+    }))), Effect.tap(() => Effect.sync(() => {
+        const out = stdoutLines.join('');
+        expect(out).toContain('Page');
+        expect(out).toContain('subtitle');
+        expect(out).toContain('Sub');
+        expect(out).toContain('created_at');
+        // Friendly form: `YYYY-MM-DD HH:mm (... ago/in ...)`.
+        // Day-of-month is timezone-dependent for a UTC midnight input,
+        // so we only assert the year/month and the relative suffix.
+        expect(out).toMatch(/created_at\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}/);
+        expect(out).toMatch(/\((?:in |[\w ]+ago)/);
+        expect(out).toContain('Fallback text');
+        expect(stderrLines.join('')).toContain('unsupported --output value for post: table');
+    })), Effect.provide(Renderer.Default)));
+});
+describe('Renderer — pure document renderers', () => {
+    it('renders generic readable scalars, dates, nested arrays, and sparse values', () => {
+        const rendered = renderReadableGeneric({
+            title: 'Generic',
+            createdAt: new Date('2026-01-02T00:00:00Z'),
+            empty: '',
+            scalarList: [1, null, new Date('2026-01-01T00:00:00Z')],
+            mixedList: [{ name: 'first' }, ['nested', null], 'tail'],
+            nested: {
+                omitted: null,
+                value: true,
+            },
+        });
+        expect(rendered).toContain('title: Generic');
+        // Friendly form: timezone-dependent for a UTC midnight input.
+        expect(rendered).toMatch(/createdAt: \d{4}-\d{2}-\d{2} \d{2}:\d{2}/);
+        expect(rendered).not.toContain('empty:');
+        expect(rendered).toMatch(/scalarList: 1, \d{4}-\d{2}-\d{2} \d{2}:\d{2}/);
+        expect(rendered).toContain('- name: first');
+        expect(rendered).toContain('  - nested');
+        expect(rendered).toContain('- tail');
+        expect(rendered).toContain('nested:');
+        expect(rendered).toContain('  value: true');
+        expect(renderReadableGeneric('plain')).toBe('plain');
+    });
+    it('renders fallback lexical content, escaped envelope meta, and scalar variants', () => {
+        const readable = noteView.readable({
+            id: 'n1',
+            title: 'Note',
+            slug: 'note',
+            is_published: false,
+            topic: 'life',
+            mood: { name: 'calm' },
+            weather: ['sun', 'wind'],
+            publicAt: new Date('2026-01-01T00:00:00Z'),
+            bookmark: true,
+            source_lang: 'zh',
+            is_translated: true,
+            contentFormat: 'lexical',
+            content: '{bad json',
+            text: 'Plain fallback',
+        }, viewCtx);
+        expect(readable).toContain('Note');
+        expect(readable).toContain('topic');
+        expect(readable).toContain('life');
+        expect(readable).toContain('weather');
+        expect(readable).toContain('sun, wind');
+        expect(readable).toContain('Plain fallback');
+        const envelope = postView.xml({
+            title: 'A & B < C',
+            slug: 'a-b',
+            category: { id: 'cat-id' },
+            isPublished: true,
+            summary: 'Summary > detail',
+            tags: ['x&y', '<z>'],
+            contentFormat: 'markdown',
+            content: 'Body',
+        });
+        expect(envelope).toContain('<title>A &amp; B &lt; C</title>');
+        expect(envelope).toContain('<category>cat-id</category>');
+        expect(envelope).toContain('<state>publish</state>');
+        expect(envelope).toContain('<tag>x&amp;y</tag>');
+        expect(envelope).toContain('<tag>&lt;z&gt;</tag>');
+        const list = postListView.readable({
+            data: [
+                {
+                    id: 'p1',
+                    category: { slug: 'tech' },
+                    is_published: false,
+                    created_at: new Date('2026-01-01T00:00:00Z'),
+                },
+            ],
+            // V3 envelope shape (post envelope-compat normalization).
+            meta: { pagination: { page: 2, size: 5, total: 9 } },
+        }, viewCtx);
+        expect(list).toContain('page: 2');
+        expect(list).toContain('size: 5');
+        expect(list).toContain('total: 9');
+        expect(list).toContain('category: tech');
+        expect(list).toContain('state: draft');
+    });
+    it('reads source_lang and translated from meta.translation when the doc itself omits them', () => {
+        const envelope = {
+            data: {
+                id: 'p1',
+                title: 'Translated title',
+                slug: 'translated',
+                is_published: true,
+                contentFormat: 'markdown',
+                content: 'body',
+                text: 'body',
+            },
+            meta: {
+                translation: {
+                    p1: {
+                        article: {
+                            is_translated: true,
+                            source_lang: 'zh',
+                            target_lang: 'en',
+                        },
+                    },
+                },
+            },
+        };
+        const readable = postView.readable(envelope, viewCtx);
+        expect(readable).toMatch(/source_lang\s+zh/);
+        expect(readable).toMatch(/translated\s+true/);
+        const noteEnvelope = {
+            ...envelope,
+            data: { ...envelope.data, topic: 'life' },
+        };
+        const noteReadable = noteView.readable(noteEnvelope, viewCtx);
+        expect(noteReadable).toMatch(/source_lang\s+zh/);
+        expect(noteReadable).toMatch(/translated\s+true/);
+        const pageReadable = pageView.readable(envelope, viewCtx);
+        expect(pageReadable).toMatch(/source_lang\s+zh/);
+        expect(pageReadable).toMatch(/translated\s+true/);
+    });
+    it('falls back to meta.translation per-row for the post list view', () => {
+        const list = postListView.readable({
+            data: [
+                { id: 'p1', title: 'A' },
+                { id: 'p2', title: 'B' },
+            ],
+            meta: {
+                translation: {
+                    p1: {
+                        article: {
+                            is_translated: true,
+                            source_lang: 'zh',
+                            target_lang: 'en',
+                        },
+                    },
+                },
+            },
+        }, viewCtx);
+        expect(list).toContain('source_lang: zh');
+        expect(list).toContain('translated: true');
+    });
+});

package/dist/test/services/Resolver.test.d.ts

@@ -0,0 +1 @@
+export {};