@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/services/Editor.test.js

@@ -0,0 +1,205 @@
+import { promises as fs } from 'node:fs';
+import { EventEmitter } from 'node:events';
+import os from 'node:os';
+import path from 'node:path';
+import * as Clack from '@clack/prompts';
+import { NodeContext } from '@effect/platform-node';
+import { it } from '@effect/vitest';
+import { Effect } from 'effect';
+import { describe, expect, vi } from 'vitest';
+import { ValidationFailed } from '../../src/domain/errors';
+import { Editor } from '../../src/services/Editor';
+vi.mock('@clack/prompts', () => ({
+    confirm: vi.fn(),
+    isCancel: vi.fn(() => false),
+    text: vi.fn(),
+}));
+const EditorLive = Editor.Default.pipe(
+// Editor depends on FileSystem from @effect/platform; NodeContext provides it.
+(layer) => layer);
+describe('Editor — readFileOrStdin', () => {
+    it.effect('reads a real file from disk', () => Effect.gen(function* () {
+        const dir = yield* Effect.promise(() => fs.mkdtemp(path.join(os.tmpdir(), 'mxs-editor-test-')));
+        const file = path.join(dir, 'sample.txt');
+        yield* Effect.promise(() => fs.writeFile(file, 'hello\n', 'utf8'));
+        const editor = yield* Editor;
+        const contents = yield* editor.readFileOrStdin(file);
+        expect(contents).toBe('hello\n');
+        yield* Effect.promise(() => fs.rm(dir, { recursive: true, force: true }));
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+    it.effect('returns ValidationFailed for a missing file', () => Effect.gen(function* () {
+        const editor = yield* Editor;
+        const result = yield* Effect.either(editor.readFileOrStdin('/nonexistent/path/that/should/not/exist.txt'));
+        expect(result._tag).toBe('Left');
+        if (result._tag === 'Left') {
+            expect(result.left).toBeInstanceOf(ValidationFailed);
+        }
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+});
+describe('Editor — service shape', () => {
+    it.effect('exposes openEditor / prompt / confirm / readFileOrStdin', () => Effect.gen(function* () {
+        const editor = yield* Editor;
+        expect(typeof editor.openEditor).toBe('function');
+        expect(typeof editor.prompt).toBe('function');
+        expect(typeof editor.confirm).toBe('function');
+        expect(typeof editor.readFileOrStdin).toBe('function');
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+    it.effect('openEditor fails fast when $EDITOR is unset', () => Effect.gen(function* () {
+        // Snapshot + clear env vars.
+        const prevEditor = process.env.EDITOR;
+        const prevVisual = process.env.VISUAL;
+        delete process.env.EDITOR;
+        delete process.env.VISUAL;
+        try {
+            const editor = yield* Editor;
+            const result = yield* Effect.either(editor.openEditor({ filename: 'x.txt', initialContent: '' }));
+            expect(result._tag).toBe('Left');
+            if (result._tag === 'Left') {
+                expect(result.left._tag).toBe('Generic');
+            }
+        }
+        finally {
+            if (prevEditor !== undefined)
+                process.env.EDITOR = prevEditor;
+            if (prevVisual !== undefined)
+                process.env.VISUAL = prevVisual;
+        }
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+    it.effect('openEditor round-trips through an explicit editor command', () => Effect.gen(function* () {
+        const editor = yield* Editor;
+        const node = process.execPath;
+        const script = "require('fs').writeFileSync(process.argv[1], 'edited', 'utf8')";
+        const result = yield* editor.openEditor({
+            filename: 'roundtrip.txt',
+            initialContent: 'initial',
+            editor: `${JSON.stringify(node)} -e ${JSON.stringify(script)}`,
+        });
+        expect(result).toBe('edited');
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+    it.effect('openEditor maps a nonzero editor exit to Generic', () => Effect.gen(function* () {
+        const editor = yield* Editor;
+        const result = yield* Effect.either(editor.openEditor({
+            filename: 'fail.txt',
+            initialContent: 'initial',
+            editor: `${JSON.stringify(process.execPath)} -e "process.exit(7)"`,
+        }));
+        expect(result._tag).toBe('Left');
+        if (result._tag === 'Left') {
+            expect(result.left._tag).toBe('Generic');
+            expect(result.left.message).toContain('editor exited with code 7');
+        }
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+});
+describe('Editor — prompts', () => {
+    it.effect('prompt and confirm return clack values', () => Effect.gen(function* () {
+        const textSpy = vi.mocked(Clack.text).mockResolvedValue('answer');
+        const confirmSpy = vi.mocked(Clack.confirm).mockResolvedValue(true);
+        try {
+            const editor = yield* Editor;
+            const answer = yield* editor.prompt('Question', {
+                initialValue: 'default',
+                placeholder: 'placeholder',
+            });
+            const ok = yield* editor.confirm('Confirm?', { initialValue: true });
+            expect(answer).toBe('answer');
+            expect(ok).toBe(true);
+            expect(textSpy).toHaveBeenCalledWith({
+                message: 'Question',
+                initialValue: 'default',
+                placeholder: 'placeholder',
+            });
+            expect(confirmSpy).toHaveBeenCalledWith({
+                message: 'Confirm?',
+                initialValue: true,
+            });
+        }
+        finally {
+            textSpy.mockReset();
+            confirmSpy.mockReset();
+        }
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+    it.effect('prompt and confirm map cancellation to Generic', () => Effect.gen(function* () {
+        const cancel = Symbol('cancel');
+        const isCancelSpy = vi
+            .mocked(Clack.isCancel)
+            .mockImplementation((value) => value === cancel);
+        const textSpy = vi
+            .mocked(Clack.text)
+            .mockResolvedValue(cancel);
+        const confirmSpy = vi
+            .mocked(Clack.confirm)
+            .mockResolvedValue(cancel);
+        try {
+            const editor = yield* Editor;
+            const promptResult = yield* Effect.either(editor.prompt('Question'));
+            const confirmResult = yield* Effect.either(editor.confirm('Confirm?'));
+            expect(promptResult._tag).toBe('Left');
+            expect(confirmResult._tag).toBe('Left');
+            if (promptResult._tag === 'Left') {
+                expect(promptResult.left._tag).toBe('Generic');
+            }
+            if (confirmResult._tag === 'Left') {
+                expect(confirmResult.left._tag).toBe('Generic');
+            }
+        }
+        finally {
+            isCancelSpy.mockReset();
+            textSpy.mockReset();
+            confirmSpy.mockReset();
+        }
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+    it.effect('prompt and confirm map clack rejections to Generic', () => Effect.gen(function* () {
+        const textSpy = vi.mocked(Clack.text).mockRejectedValue('text failed');
+        const confirmSpy = vi
+            .mocked(Clack.confirm)
+            .mockRejectedValue(new Error('confirm failed'));
+        try {
+            const editor = yield* Editor;
+            const promptResult = yield* Effect.either(editor.prompt('Question'));
+            const confirmResult = yield* Effect.either(editor.confirm('Confirm?'));
+            expect(promptResult._tag).toBe('Left');
+            expect(confirmResult._tag).toBe('Left');
+            if (promptResult._tag === 'Left') {
+                expect(promptResult.left.message).toBe('text failed');
+            }
+            if (confirmResult._tag === 'Left') {
+                expect(confirmResult.left.message).toBe('confirm failed');
+            }
+        }
+        finally {
+            textSpy.mockReset();
+            confirmSpy.mockReset();
+        }
+    }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+});
+describe('Editor — stdin', () => {
+    it.effect('reads from stdin when path is "-"', () => Effect.gen(function* () {
+        const fakeStdin = new EventEmitter();
+        fakeStdin.isPaused = () => true;
+        fakeStdin.resume = vi.fn(() => {
+            queueMicrotask(() => {
+                fakeStdin.emit('data', 'hello ');
+                fakeStdin.emit('data', Buffer.from('world'));
+                fakeStdin.emit('end');
+            });
+        });
+        const descriptor = Object.getOwnPropertyDescriptor(process, 'stdin');
+        Object.defineProperty(process, 'stdin', {
+            configurable: true,
+            value: fakeStdin,
+        });
+        try {
+            const promise = Effect.runPromise(Effect.gen(function* () {
+                const editor = yield* Editor;
+                return yield* editor.readFileOrStdin('-');
+            }).pipe(Effect.provide(EditorLive), Effect.provide(NodeContext.layer)));
+            const result = yield* Effect.promise(() => promise);
+            expect(result).toBe('hello world');
+            expect(fakeStdin.resume).toHaveBeenCalledOnce();
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process, 'stdin', descriptor);
+        }
+    }));
+});

package/dist/test/services/Lexical.errors.test.d.ts

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

package/dist/test/services/Lexical.errors.test.js

@@ -0,0 +1,60 @@
+import { Effect } from 'effect';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const editorMock = vi.hoisted(() => ({
+    deserializeMxLitexmlToLexical: vi.fn(),
+    mxLexicalToMarkdown: vi.fn(() => ''),
+    serializeMxLexicalToLitexml: vi.fn(),
+    stripMxLitexmlDocWrapper: vi.fn((xml) => xml),
+}));
+vi.mock('@mx-space/editor', () => ({
+    deserializeMxLitexmlToLexical: editorMock.deserializeMxLitexmlToLexical,
+    mxLexicalToMarkdown: editorMock.mxLexicalToMarkdown,
+    serializeMxLexicalToLitexml: editorMock.serializeMxLexicalToLitexml,
+    stripMxLitexmlDocWrapper: editorMock.stripMxLitexmlDocWrapper,
+}));
+import { Lexical } from '../../src/services/Lexical';
+describe('Lexical service dependency failures', () => {
+    beforeEach(() => {
+        editorMock.deserializeMxLitexmlToLexical.mockReturnValue({
+            root: { type: 'root', children: [] },
+        });
+        editorMock.serializeMxLexicalToLitexml.mockReturnValue('<doc />');
+        editorMock.stripMxLitexmlDocWrapper.mockImplementation((xml) => xml);
+        editorMock.mxLexicalToMarkdown.mockReturnValue('');
+    });
+    it('maps LiteXML parse dependency failures to ValidationXml', async () => {
+        editorMock.deserializeMxLitexmlToLexical.mockImplementation(() => {
+            throw 'parse failed';
+        });
+        const err = await Effect.runPromise(Effect.gen(function* () {
+            const lexical = yield* Lexical;
+            return yield* Effect.flip(lexical.litexmlToPayload('<p>x</p>'));
+        }).pipe(Effect.provide(Lexical.Default)));
+        expect(err._tag).toBe('ValidationXml');
+        expect(err.message).toContain('failed to parse LiteXML');
+    });
+    it('maps LiteXML serialization dependency failures to ValidationXml', async () => {
+        editorMock.serializeMxLexicalToLitexml.mockImplementation(() => {
+            throw new Error('serialize failed');
+        });
+        const err = await Effect.runPromise(Effect.gen(function* () {
+            const lexical = yield* Lexical;
+            return yield* Effect.flip(lexical.payloadToLitexml({ root: { type: 'root', children: [] } }));
+        }).pipe(Effect.provide(Lexical.Default)));
+        expect(err._tag).toBe('ValidationXml');
+        expect(err.message).toContain('failed to serialize Lexical state');
+    });
+    it('maps Markdown rendering dependency failures to ValidationXml', async () => {
+        editorMock.mxLexicalToMarkdown.mockImplementation(() => {
+            throw { message: 'sanitize failed' };
+        });
+        const err = await Effect.runPromise(Effect.gen(function* () {
+            const lexical = yield* Lexical;
+            return yield* Effect.flip(lexical.lexicalJsonToMarkdown({
+                root: { type: 'root', children: [] },
+            }));
+        }).pipe(Effect.provide(Lexical.Default)));
+        expect(err._tag).toBe('ValidationXml');
+        expect(err.message).toContain('failed to render Markdown');
+    });
+});

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

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

package/dist/test/services/Lexical.test.js

@@ -0,0 +1,68 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { it } from '@effect/vitest';
+import { Effect } from 'effect';
+import { describe, expect } from 'vitest';
+import { Lexical } from '../../src/services/Lexical';
+const fixture = (name) => readFileSync(path.resolve(__dirname, '../fixtures', name), 'utf8');
+describe('Lexical service', () => {
+    it.effect('parses litexml content into a Lexical state', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.litexmlToPayload('<p>hello</p>');
+        expect(state.root.type).toBe('root');
+        expect(state.root.children.length).toBeGreaterThan(0);
+    }).pipe(Effect.provide(Lexical.Default)));
+    it.effect('accepts an already wrapped <doc> payload', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.litexmlToPayload('<doc><p>hello</p></doc>');
+        expect(state.root.children.length).toBeGreaterThan(0);
+    }).pipe(Effect.provide(Lexical.Default)));
+    it.effect('round-trips paragraph content', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.litexmlToPayload('<p>hello world</p>');
+        const xml = yield* lexical.payloadToLitexml(state);
+        expect(xml).toContain('<p>');
+        expect(xml).toContain('hello world');
+    }).pipe(Effect.provide(Lexical.Default)));
+    it.effect('round-trips mx custom nodes through LiteXML fallback nodes', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.litexmlToPayload('<node type="map" id="map-1" data="{&quot;title&quot;:&quot;Shanghai&quot;,&quot;pois&quot;:[{&quot;title&quot;:&quot;Bund&quot;}]}" />');
+        const mapNode = state.root.children[0];
+        expect(mapNode.type).toBe('map');
+        expect(mapNode.$?.blockId).toBe('map-1');
+        expect(mapNode.title).toBe('Shanghai');
+        const xml = yield* lexical.payloadToLitexml(state);
+        expect(xml).toContain('<node type="map" id="map-1"');
+        expect(xml).toContain('&quot;title&quot;:&quot;Shanghai&quot;');
+        expect(xml).toContain('&quot;title&quot;:&quot;Bund&quot;');
+    }).pipe(Effect.provide(Lexical.Default)));
+    it.effect('renders markdown from lexical state', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.litexmlToPayload('<p>hello</p>');
+        const md = yield* lexical.lexicalJsonToMarkdown(state);
+        expect(typeof md).toBe('string');
+        expect(md.length).toBeGreaterThan(0);
+    }).pipe(Effect.provide(Lexical.Default)));
+    it.effect('exposes an empty state factory', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.emptyState;
+        expect(state.root.type).toBe('root');
+        expect(state.root.children).toEqual([]);
+    }).pipe(Effect.provide(Lexical.Default)));
+    it.effect('parses the post.xml fixture content section', () => Effect.gen(function* () {
+        const lexical = yield* Lexical;
+        const state = yield* lexical.litexmlToPayload('<p>正文一</p><h2>章节</h2>');
+        expect(state.root.children.length).toBeGreaterThan(0);
+    }).pipe(Effect.provide(Lexical.Default)));
+    // Fixture files exist — use them as additional smoke coverage so this test
+    // breaks if the fixtures change unexpectedly.
+    it('post.xml fixture parses non-empty', () => {
+        expect(fixture('post.xml')).toContain('<mxpost>');
+    });
+    it('post-bad.xml fixture is malformed', () => {
+        expect(fixture('post-bad.xml')).toContain('<p>unterminated');
+    });
+    it('note.xml fixture parses non-empty', () => {
+        expect(fixture('note.xml')).toContain('<mxnote>');
+    });
+});

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

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