@mx-space/cli 0.15.1 → 0.15.2

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

@@ -1,205 +0,0 @@
-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

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

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

@@ -1,60 +0,0 @@
-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

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

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

@@ -1,68 +0,0 @@
-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

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