@mx-space/cli 0.15.1 → 0.15.2

package/dist/test/services/Resolver.test.js

@@ -1,320 +0,0 @@
-import { Effect, Layer } from 'effect';
-import { describe, expect, it, vi } from 'vitest';
-import { Api, } from '../../src/services/Api';
-import { Generic } from '../../src/domain/errors';
-import { isSnowflakeId, layer as resolverLayer, make, matchItem, Resolver, } from '../../src/services/Resolver';
-function mockApi(responses) {
-    const raw = (path, _options) => Effect.tryPromise({
-        try: async () => {
-            if (!(path in responses)) {
-                throw new Error(`unexpected request: ${path}`);
-            }
-            const v = responses[path];
-            return typeof v === 'function' ? await v() : v;
-        },
-        catch: (e) => new Generic({
-            message: String(e?.message ?? e),
-        }),
-    });
-    const request = (path, options) => raw(path, options);
-    return { request, raw };
-}
-// ---------------------------------------------------------------------------
-// Pure helpers
-// ---------------------------------------------------------------------------
-describe('isSnowflakeId', () => {
-    it('accepts 15-digit numeric ids', () => {
-        expect(isSnowflakeId('123456789012345')).toBe(true);
-        expect(isSnowflakeId('1234567890123456789')).toBe(true);
-    });
-    it('rejects short ids and slugs', () => {
-        expect(isSnowflakeId('12345')).toBe(false);
-        expect(isSnowflakeId('hello-world')).toBe(false);
-    });
-});
-describe('matchItem', () => {
-    const items = [
-        { id: 'a', slug: 'blog', name: 'Blog' },
-        { id: 'b', slug: 'tech', name: 'Technology' },
-    ];
-    it('matches by exact slug', () => {
-        expect(matchItem(items, 'tech')?.id).toBe('b');
-    });
-    it('matches by exact name', () => {
-        expect(matchItem(items, 'Blog')?.id).toBe('a');
-    });
-    it('matches case-insensitively as fallback', () => {
-        expect(matchItem(items, 'BLOG')?.id).toBe('a');
-    });
-    it('returns null when nothing matches', () => {
-        expect(matchItem(items, 'nope')).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// resolveCategory / resolveTopic via in-memory mock Api
-// ---------------------------------------------------------------------------
-describe('resolveCategory / resolveTopic', () => {
-    it('returns snowflake ids unchanged without a request', async () => {
-        const api = mockApi({});
-        const svc = make(api);
-        const id = await Effect.runPromise(svc.resolveCategory('123456789012345'));
-        expect(id).toBe('123456789012345');
-    });
-    it('resolves a slug through /categories', async () => {
-        const api = mockApi({
-            '/categories': { data: [{ id: 'cat-1', slug: 'blog', name: 'Blog' }] },
-        });
-        const svc = make(api);
-        const id = await Effect.runPromise(svc.resolveCategory('blog'));
-        expect(id).toBe('cat-1');
-    });
-    it('fails ValidationFailed with suggestions on unknown slug', async () => {
-        const api = mockApi({
-            '/categories': { data: [{ id: 'cat-1', slug: 'blog', name: 'Blog' }] },
-        });
-        const svc = make(api);
-        const exit = await Effect.runPromiseExit(svc.resolveCategory('blo'));
-        expect(exit._tag).toBe('Failure');
-        if (exit._tag === 'Failure') {
-            const err = extractError(exit.cause);
-            expect(err?._tag).toBe('ValidationFailed');
-            expect(err.message).toMatch(/category "blo" not found/);
-            // suggestion label picks `name` before `slug` (legacy fuzzySuggest behavior)
-            expect(err.details?.issues?.[0]?.suggestions).toContain('Blog');
-        }
-    });
-    it('hits topic endpoint /topics/all', async () => {
-        const api = mockApi({
-            '/topics/all': [{ id: 'topic-1', slug: 'misc', name: 'Misc' }],
-        });
-        const svc = make(api);
-        const id = await Effect.runPromise(svc.resolveTopic('misc'));
-        expect(id).toBe('topic-1');
-    });
-    it('caches list within ttl window', async () => {
-        const responses = {
-            '/categories': vi.fn(() => ({
-                data: [{ id: 'cat-1', slug: 'blog' }],
-            })),
-        };
-        const api = mockApi(responses);
-        const svc = make(api);
-        await Effect.runPromise(svc.resolveCategory('blog'));
-        await Effect.runPromise(svc.resolveCategory('blog'));
-        expect(responses['/categories']).toHaveBeenCalledTimes(1);
-    });
-    it('invalidate(kind) forces re-fetch', async () => {
-        const responses = {
-            '/categories': vi.fn(() => ({
-                data: [{ id: 'cat-1', slug: 'blog' }],
-            })),
-        };
-        const api = mockApi(responses);
-        const svc = make(api);
-        await Effect.runPromise(svc.resolveCategory('blog'));
-        await Effect.runPromise(svc.invalidate('category'));
-        await Effect.runPromise(svc.resolveCategory('blog'));
-        expect(responses['/categories']).toHaveBeenCalledTimes(2);
-    });
-});
-// ---------------------------------------------------------------------------
-// resolveCategoryRefs
-// ---------------------------------------------------------------------------
-describe('resolveCategoryRefs', () => {
-    it('maps a list of slugs/ids to ids', async () => {
-        const api = mockApi({
-            '/categories': {
-                data: [
-                    { id: 'cat-1', slug: 'blog' },
-                    { id: 'cat-2', slug: 'tech' },
-                ],
-            },
-        });
-        const svc = make(api);
-        const ids = await Effect.runPromise(svc.resolveCategoryRefs(['blog', '999999999999999', 'tech']));
-        expect(ids).toEqual(['cat-1', '999999999999999', 'cat-2']);
-    });
-    it('fails on first unknown ref', async () => {
-        const api = mockApi({
-            '/categories': { data: [{ id: 'cat-1', slug: 'blog' }] },
-        });
-        const svc = make(api);
-        const exit = await Effect.runPromiseExit(svc.resolveCategoryRefs(['blog', 'missing']));
-        expect(exit._tag).toBe('Failure');
-        if (exit._tag === 'Failure') {
-            expect(extractError(exit.cause)?._tag).toBe('ValidationFailed');
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Direct API resolvers (port of commands/post/note/category/resolve.ts)
-// ---------------------------------------------------------------------------
-describe('resolvePostReadPath / resolvePostId', () => {
-    it('resolves ordinary post slugs through /posts/get-url', async () => {
-        const api = mockApi({
-            '/posts/get-url/hello-world': { path: '/writing/hello-world' },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolvePostReadPath('hello-world'))).toBe('/posts/writing/hello-world');
-    });
-    it('resolves a post id by reading the resolved category route', async () => {
-        const api = mockApi({
-            '/posts/get-url/hello-world': { path: '/writing/hello-world' },
-            '/posts/writing/hello-world': { id: 'post-1' },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolvePostId('hello-world'))).toBe('post-1');
-    });
-    it('keeps snowflake ids without a network round-trip', async () => {
-        const api = mockApi({});
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolvePostReadPath('123456789012345'))).toBe('/posts/123456789012345');
-    });
-    it('fails ResourceNotFound when /posts/get-url returns no path', async () => {
-        const api = mockApi({
-            '/posts/get-url/missing': {},
-        });
-        const svc = make(api);
-        const exit = await Effect.runPromiseExit(svc.resolvePostId('missing'));
-        expect(exit._tag).toBe('Failure');
-        if (exit._tag === 'Failure') {
-            expect(extractError(exit.cause)?._tag).toBe('ResourceNotFound');
-        }
-    });
-    it('unwraps the response envelope ({ data: { path } }) from /posts/get-url', async () => {
-        const api = mockApi({
-            '/posts/get-url/aws-vless': { data: { path: '/writing/aws-vless' } },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolvePostReadPath('aws-vless'))).toBe('/posts/writing/aws-vless');
-    });
-    it('unwraps the response envelope ({ data: { id } }) from the post detail route', async () => {
-        const api = mockApi({
-            '/posts/get-url/aws-vless': { data: { path: '/writing/aws-vless' } },
-            '/posts/writing/aws-vless': { data: { id: 'post-9' }, meta: {} },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolvePostId('aws-vless'))).toBe('post-9');
-    });
-});
-describe('resolveNoteId', () => {
-    it('returns snowflake ids unchanged', async () => {
-        const api = mockApi({});
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolveNoteId('123456789012345'))).toBe('123456789012345');
-    });
-    it('resolves numeric nid through /notes/nid/:nid envelope', async () => {
-        const api = mockApi({
-            '/notes/nid/42': { data: { id: 'note-1', nid: 42 } },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolveNoteId('42'))).toBe('note-1');
-    });
-    it('accepts the flat envelope shape', async () => {
-        const api = mockApi({
-            '/notes/nid/7': { id: 'note-flat' },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolveNoteId('7'))).toBe('note-flat');
-    });
-    it('rejects non-snowflake non-numeric input with ValidationFailed', async () => {
-        const api = mockApi({});
-        const svc = make(api);
-        const exit = await Effect.runPromiseExit(svc.resolveNoteId('hello-world'));
-        expect(exit._tag).toBe('Failure');
-        if (exit._tag === 'Failure') {
-            const err = extractError(exit.cause);
-            expect(err?._tag).toBe('ValidationFailed');
-            expect(err.message).toMatch(/invalid note reference: hello-world/);
-        }
-    });
-    it('fails ResourceNotFound when nid lookup returns no id', async () => {
-        const api = mockApi({
-            '/notes/nid/99': { data: {} },
-        });
-        const svc = make(api);
-        const exit = await Effect.runPromiseExit(svc.resolveNoteId('99'));
-        expect(exit._tag).toBe('Failure');
-        if (exit._tag === 'Failure') {
-            expect(extractError(exit.cause)?._tag).toBe('ResourceNotFound');
-        }
-    });
-});
-describe('resolveCategoryId (direct /categories/:slug envelope)', () => {
-    it('returns snowflake ids unchanged', async () => {
-        const api = mockApi({});
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolveCategoryId('123456789012345'))).toBe('123456789012345');
-    });
-    it('unwraps the double envelope', async () => {
-        const api = mockApi({
-            '/categories/blog': { data: { id: 'cat-1', name: 'Blog' } },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolveCategoryId('blog'))).toBe('cat-1');
-    });
-    it('percent-encodes slug characters before hitting the API', async () => {
-        const api = mockApi({
-            '/categories/hello%20world': { data: { id: 'cat-2' } },
-        });
-        const svc = make(api);
-        expect(await Effect.runPromise(svc.resolveCategoryId('hello world'))).toBe('cat-2');
-    });
-    it('fails ResourceNotFound when envelope has no id', async () => {
-        const api = mockApi({
-            '/categories/missing': { data: {} },
-        });
-        const svc = make(api);
-        const exit = await Effect.runPromiseExit(svc.resolveCategoryId('missing'));
-        expect(exit._tag).toBe('Failure');
-        if (exit._tag === 'Failure') {
-            const err = extractError(exit.cause);
-            expect(err?._tag).toBe('ResourceNotFound');
-            expect(err.message).toMatch(/category not found: missing/);
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// Layer wiring: Default Resolver layer composes from Api
-// ---------------------------------------------------------------------------
-describe('Resolver tag layer wiring', () => {
-    it('composes via Layer with an ambient Api service', async () => {
-        const api = mockApi({
-            '/categories': { data: [{ id: 'cat-1', slug: 'blog' }] },
-        });
-        const program = Effect.gen(function* () {
-            const r = yield* Resolver;
-            return yield* r.resolveCategory('blog');
-        });
-        const apiLayer = Layer.succeed(Api, api);
-        const out = await Effect.runPromise(program.pipe(Effect.provide(Resolver.Default), Effect.provide(apiLayer)));
-        expect(out).toBe('cat-1');
-    });
-    it('layer(api) helper exposes Resolver service directly', async () => {
-        const api = mockApi({
-            '/categories': { data: [{ id: 'cat-1', slug: 'blog' }] },
-        });
-        const program = Effect.flatMap(Resolver, (r) => r.resolveCategory('blog'));
-        const out = await Effect.runPromise(program.pipe(Effect.provide(resolverLayer(api))));
-        expect(out).toBe('cat-1');
-    });
-});
-function extractError(cause) {
-    const seen = new Set();
-    const visit = (node) => {
-        if (!node || typeof node !== 'object' || seen.has(node))
-            return undefined;
-        seen.add(node);
-        const obj = node;
-        if (typeof obj._tag === 'string' && obj._tag !== 'Die' && obj._tag !== 'Fail' && obj._tag !== 'Sequential' && obj._tag !== 'Parallel' && obj._tag !== 'Interrupt' && obj._tag !== 'Empty' && obj._tag !== 'Annotated') {
-            return obj;
-        }
-        for (const v of Object.values(obj)) {
-            const t = visit(v);
-            if (t)
-                return t;
-        }
-        return undefined;
-    };
-    return visit(cause);
-}

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

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

package/dist/test/services/Skill.test.js

@@ -1,261 +0,0 @@
-import { Effect, Exit, Layer } from 'effect';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { Skill } from '../../src/services/Skill';
-import { makeMemFs, TestFsLive, TestPathLive } from '../helper/test-fs';
-const CLI_DIR = '/test/cli-skills';
-const HAKLEX_DIR = '/test/haklex-skills';
-const chapter = (slug, title, description, order, body) => `---\nslug: ${slug}\ntitle: ${title}\ndescription: ${description}\norder: ${order}\n---\n\n${body}\n`;
-const makeLayer = (seed) => {
-    const mem = makeMemFs();
-    seed(mem);
-    const fsLayer = TestFsLive(mem);
-    const baseLayer = Layer.merge(fsLayer, TestPathLive);
-    const skillLayer = Skill.Default.pipe(Layer.provide(baseLayer));
-    return Layer.mergeAll(baseLayer, skillLayer);
-};
-const tagOf = (cause) => {
-    const err = cause?.error ?? cause?.failure ?? cause;
-    return err?._tag ?? err?.error?._tag ?? err?.failure?._tag;
-};
-beforeEach(() => {
-    process.env.MXS_SKILL_CLI_DIR = CLI_DIR;
-    process.env.MXS_SKILL_HAKLEX_DIR = HAKLEX_DIR;
-});
-afterEach(() => {
-    delete process.env.MXS_SKILL_CLI_DIR;
-    delete process.env.MXS_SKILL_HAKLEX_DIR;
-});
-describe('Skill.list', () => {
-    it('returns chapters sorted by order, with cli + haklex sources merged', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(HAKLEX_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${HAKLEX_DIR}/references`, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/overview.md`, {
-                type: 'file',
-                data: chapter('overview', 'Overview', 'desc-0', 0, 'body 0'),
-                mode: 0o644,
-            });
-            mem.nodes.set(`${CLI_DIR}/safety.md`, {
-                type: 'file',
-                data: chapter('safety', 'Safety', 'desc-60', 60, 'body 60'),
-                mode: 0o644,
-            });
-            mem.nodes.set(`${HAKLEX_DIR}/SKILL.md`, {
-                type: 'file',
-                data: `---\nname: litexml-authoring\ndescription: haklex overview\n---\n\nliteXML body\n`,
-                mode: 0o644,
-            });
-            mem.nodes.set(`${HAKLEX_DIR}/references/cli.md`, {
-                type: 'file',
-                data: `# cli reference\n\nbody\n`,
-                mode: 0o644,
-            });
-        });
-        const result = await Effect.runPromise(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.list;
-        }).pipe(Effect.provide(layer)));
-        expect(result.map((c) => c.slug)).toEqual([
-            'overview',
-            'safety',
-            'litexml',
-            'litexml-cli',
-        ]);
-        expect(result.find((c) => c.slug === 'litexml')?.source).toBe('haklex');
-        expect(result.find((c) => c.slug === 'litexml-cli')?.source).toBe('haklex');
-        expect(result[0].source).toBe('cli');
-    });
-    it('fails with SkillCorpusEmpty when both sources are empty', async () => {
-        const layer = makeLayer(() => { });
-        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.list;
-        }).pipe(Effect.provide(layer)));
-        expect(Exit.isFailure(exit)).toBe(true);
-        if (Exit.isFailure(exit)) {
-            expect(tagOf(exit.cause)).toBe('SkillCorpusEmpty');
-        }
-    });
-});
-describe('Skill.get', () => {
-    it('fetches a chapter by slug', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/overview.md`, {
-                type: 'file',
-                data: chapter('overview', 'Overview', 'desc', 0, 'body'),
-                mode: 0o644,
-            });
-        });
-        const result = await Effect.runPromise(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.get('overview');
-        }).pipe(Effect.provide(layer)));
-        expect(result.title).toBe('Overview');
-        expect(result.body.trim()).toBe('body');
-    });
-    it('fails with ChapterNotFound when slug is missing', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/overview.md`, {
-                type: 'file',
-                data: chapter('overview', 'Overview', 'desc', 0, 'body'),
-                mode: 0o644,
-            });
-        });
-        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.get('nonexistent');
-        }).pipe(Effect.provide(layer)));
-        expect(Exit.isFailure(exit)).toBe(true);
-        if (Exit.isFailure(exit)) {
-            expect(tagOf(exit.cause)).toBe('ChapterNotFound');
-        }
-    });
-    it('hints at haklex upgrade when missing slug starts with litexml', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/overview.md`, {
-                type: 'file',
-                data: chapter('overview', 'Overview', 'desc', 0, 'body'),
-                mode: 0o644,
-            });
-        });
-        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.get('litexml');
-        }).pipe(Effect.provide(layer)));
-        expect(Exit.isFailure(exit)).toBe(true);
-        if (Exit.isFailure(exit)) {
-            const err = exit.cause.error ?? exit.cause.failure;
-            expect(err?.hint).toMatch(/haklex/);
-        }
-    });
-});
-describe('Skill.search', () => {
-    it('returns chapters ranked by match, with snippets', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/a.md`, {
-                type: 'file',
-                data: chapter('a', 'Alpha dryrun', 'd', 0, 'first dryrun appears here\nand again dryrun in body'),
-                mode: 0o644,
-            });
-            mem.nodes.set(`${CLI_DIR}/b.md`, {
-                type: 'file',
-                data: chapter('b', 'Beta', 'all about dryrun', 1, 'no body match'),
-                mode: 0o644,
-            });
-            mem.nodes.set(`${CLI_DIR}/c.md`, {
-                type: 'file',
-                data: chapter('c', 'Gamma', 'd', 2, 'totally unrelated content'),
-                mode: 0o644,
-            });
-        });
-        const hits = await Effect.runPromise(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.search('dryrun');
-        }).pipe(Effect.provide(layer)));
-        expect(hits.length).toBe(2);
-        expect(hits[0].slug).toBe('a');
-        expect(hits[0].snippets.length).toBeGreaterThanOrEqual(2);
-        expect(hits[1].slug).toBe('b');
-    });
-    it('matches a multi-word AND query across hyphen-joined tokens', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/a.md`, {
-                type: 'file',
-                data: chapter('a', 'AI Authoring', 'AI involvement disclosure', 0, 'Fully AI-generated bodies should declare aiGen 2.'),
-                mode: 0o644,
-            });
-            mem.nodes.set(`${CLI_DIR}/b.md`, {
-                type: 'file',
-                data: chapter('b', 'Other', 'unrelated', 1, 'only ai here, no second token'),
-                mode: 0o644,
-            });
-        });
-        const hits = await Effect.runPromise(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.search('ai generated');
-        }).pipe(Effect.provide(layer)));
-        expect(hits.map((h) => h.slug)).toEqual(['a']);
-        expect(hits[0].snippets.length).toBeGreaterThan(0);
-    });
-    it('matches a prefix query (aigen → aiGen)', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/a.md`, {
-                type: 'file',
-                data: chapter('a', 'Authoring', 'meta presets', 0, 'set meta.aiGen to 2 for full AI'),
-                mode: 0o644,
-            });
-        });
-        const hits = await Effect.runPromise(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.search('aigen');
-        }).pipe(Effect.provide(layer)));
-        expect(hits.length).toBe(1);
-        expect(hits[0].slug).toBe('a');
-        expect(hits[0].snippets[0]).toMatch(/aiGen/);
-    });
-    it('returns empty array for blank keyword', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/a.md`, {
-                type: 'file',
-                data: chapter('a', 'A', 'd', 0, 'body'),
-                mode: 0o644,
-            });
-        });
-        const hits = await Effect.runPromise(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.search('   ');
-        }).pipe(Effect.provide(layer)));
-        expect(hits).toEqual([]);
-    });
-});
-describe('Skill frontmatter parser', () => {
-    it('fails when required field is missing', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/bad.md`, {
-                type: 'file',
-                data: `---\nslug: bad\ntitle: B\n---\n\nbody\n`,
-                mode: 0o644,
-            });
-        });
-        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.list;
-        }).pipe(Effect.provide(layer)));
-        expect(Exit.isFailure(exit)).toBe(true);
-        if (Exit.isFailure(exit)) {
-            expect(tagOf(exit.cause)).toBe('SkillCorpusEmpty');
-        }
-    });
-    it('fails when two cli chapters declare the same slug', async () => {
-        const layer = makeLayer((mem) => {
-            mem.nodes.set(CLI_DIR, { type: 'dir', mode: 0o755 });
-            mem.nodes.set(`${CLI_DIR}/a.md`, {
-                type: 'file',
-                data: chapter('dup', 'A', 'd', 0, 'a'),
-                mode: 0o644,
-            });
-            mem.nodes.set(`${CLI_DIR}/b.md`, {
-                type: 'file',
-                data: chapter('dup', 'B', 'd', 1, 'b'),
-                mode: 0o644,
-            });
-        });
-        const exit = await Effect.runPromiseExit(Effect.gen(function* () {
-            const skill = yield* Skill;
-            return yield* skill.list;
-        }).pipe(Effect.provide(layer)));
-        expect(Exit.isFailure(exit)).toBe(true);
-        if (Exit.isFailure(exit)) {
-            expect(tagOf(exit.cause)).toBe('SkillCorpusEmpty');
-        }
-    });
-});

package/dist/test/services/UpdateNotifier.spawn.test.d.ts

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

package/dist/test/services/UpdateNotifier.spawn.test.js

@@ -1,73 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { Effect } from 'effect';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const spawnMock = vi.hoisted(() => vi.fn());
-vi.mock('node:child_process', () => ({ spawn: spawnMock }));
-import { make } from '../../src/services/UpdateNotifier';
-const makeFetchOK = () => async () => ({
-    ok: true,
-    status: 200,
-    headers: { get: () => null },
-    async json() {
-        return { version: '9.9.9', engines: { node: '>=22' } };
-    },
-    async text() {
-        return '';
-    },
-});
-const makeChild = () => {
-    const child = new EventEmitter();
-    child.stderr = new EventEmitter();
-    return child;
-};
-describe('UpdateNotifier default spawn adapter', () => {
-    beforeEach(() => {
-        spawnMock.mockReset();
-    });
-    it('uses child_process.spawn when no spawn override is supplied', async () => {
-        spawnMock.mockImplementation(() => {
-            const child = makeChild();
-            queueMicrotask(() => {
-                child.stderr.emit('data', Buffer.from('npm notice\n'));
-                child.emit('exit', 0);
-            });
-            return child;
-        });
-        const stderrSpy = vi
-            .spyOn(process.stderr, 'write')
-            .mockImplementation(() => true);
-        try {
-            const svc = make({ fetchImpl: makeFetchOK() });
-            const res = await Effect.runPromise(svc.runUpdate({
-                currentVersion: '0.2.0',
-                entrypoint: '/usr/local/lib/node_modules/@mx-space/cli/dist/bin/mxs.mjs',
-                yes: true,
-                json: true,
-            }));
-            expect(res.upgraded).toBe(true);
-            expect(spawnMock).toHaveBeenCalledWith('npm', ['install', '-g', '@mx-space/cli@latest'], expect.objectContaining({
-                stdio: ['ignore', 'inherit', 'pipe'],
-            }));
-        }
-        finally {
-            stderrSpy.mockRestore();
-        }
-    });
-    it('turns child spawn errors into a failed update result', async () => {
-        spawnMock.mockImplementation(() => {
-            const child = makeChild();
-            queueMicrotask(() => {
-                child.emit('error', new Error('spawn denied'));
-            });
-            return child;
-        });
-        const svc = make({ fetchImpl: makeFetchOK() });
-        const exit = await Effect.runPromiseExit(svc.runUpdate({
-            currentVersion: '0.2.0',
-            entrypoint: '/usr/local/lib/node_modules/@mx-space/cli/dist/bin/mxs.mjs',
-            yes: true,
-            json: true,
-        }));
-        expect(exit._tag).toBe('Failure');
-    });
-});

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

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