@crouton-kit/crouter 0.3.16 → 0.3.18

package/dist/commands/__tests__/skill.test.js

@@ -1,290 +0,0 @@
-// Tests for the skill subtree argv-model migration.
-// Run with: node --import tsx/esm --test 'src/commands/__tests__/skill.test.ts'
-//
-// Tests exercise leaf param schemas via parseArgv (framework) — no subprocess
-// spawning, no filesystem side-effects from handler logic.
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { parseArgv } from '../../core/command.js';
-// ---------------------------------------------------------------------------
-// Shared flag param sets (mirrors the leaf definitions exactly)
-// ---------------------------------------------------------------------------
-const scopeAllFlag = {
-    kind: 'flag', name: 'scope', type: 'enum',
-    choices: ['user', 'project', 'all'], required: false, constraint: '',
-};
-const scopeWriteFlag = {
-    kind: 'flag', name: 'scope', type: 'enum',
-    choices: ['user', 'project'], required: false, constraint: '',
-};
-const pluginFlag = {
-    kind: 'flag', name: 'plugin', type: 'string', required: false, constraint: '',
-};
-const includeDisabledFlag = {
-    kind: 'flag', name: 'include-disabled', type: 'bool', required: false, constraint: '',
-};
-// ---------------------------------------------------------------------------
-// skill find list
-// ---------------------------------------------------------------------------
-describe('skill find list params', () => {
-    const params = [
-        scopeAllFlag,
-        pluginFlag,
-        includeDisabledFlag,
-        { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: '' },
-        { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: '' },
-        { kind: 'flag', name: 'full', type: 'bool', required: false, constraint: '' },
-    ];
-    test('no args: defaults applied', async () => {
-        const r = await parseArgv(params, []);
-        assert.equal(r['includeDisabled'], false);
-        assert.equal(r['limit'], 50);
-        assert.equal(r['scope'], undefined);
-        assert.equal(r['plugin'], undefined);
-        assert.equal(r['cursor'], undefined);
-    });
-    test('--scope user', async () => {
-        const r = await parseArgv(params, ['--scope', 'user']);
-        assert.equal(r['scope'], 'user');
-    });
-    test('--scope invalid rejects', async () => {
-        await assert.rejects(() => parseArgv(params, ['--scope', 'bogus']), (e) => { assert.match(e.message, /must be one of/); return true; });
-    });
-    test('--include-disabled presence = true', async () => {
-        const r = await parseArgv(params, ['--include-disabled']);
-        assert.equal(r['includeDisabled'], true);
-    });
-    test('--include-disabled=value rejects', async () => {
-        await assert.rejects(() => parseArgv(params, ['--include-disabled=yes']), (e) => { assert.match(e.message, /takes no value/); return true; });
-    });
-    test('--limit 100', async () => {
-        const r = await parseArgv(params, ['--limit', '100']);
-        assert.equal(r['limit'], 100);
-    });
-    test('--limit non-integer rejects', async () => {
-        await assert.rejects(() => parseArgv(params, ['--limit', '1.5']), (e) => { assert.match(e.message, /must be an integer/); return true; });
-    });
-    test('--cursor TOKEN', async () => {
-        const r = await parseArgv(params, ['--cursor', 'tok_abc']);
-        assert.equal(r['cursor'], 'tok_abc');
-    });
-    test('--plugin my-plugin', async () => {
-        const r = await parseArgv(params, ['--plugin', 'my-plugin']);
-        assert.equal(r['plugin'], 'my-plugin');
-    });
-    test('--full presence = true, absence = false', async () => {
-        const present = await parseArgv(params, ['--full']);
-        assert.equal(present['full'], true);
-        const absent = await parseArgv(params, []);
-        assert.equal(absent['full'], false);
-    });
-});
-// ---------------------------------------------------------------------------
-// skill find search
-// ---------------------------------------------------------------------------
-describe('skill find search params', () => {
-    const params = [
-        { kind: 'positional', name: 'query', required: true, constraint: '' },
-        scopeAllFlag,
-        pluginFlag,
-        includeDisabledFlag,
-        { kind: 'flag', name: 'search-body', type: 'bool', required: false, constraint: '' },
-    ];
-    test('query positional required', async () => {
-        await assert.rejects(() => parseArgv(params, []), (e) => { assert.match(e.message, /required parameter is missing/); return true; });
-    });
-    test('query parsed as positional', async () => {
-        const r = await parseArgv(params, ['my topic']);
-        assert.equal(r['query'], 'my topic');
-    });
-    test('query + flags', async () => {
-        const r = await parseArgv(params, ['debugging', '--scope', 'project', '--include-disabled', '--search-body']);
-        assert.equal(r['query'], 'debugging');
-        assert.equal(r['scope'], 'project');
-        assert.equal(r['includeDisabled'], true);
-        assert.equal(r['searchBody'], true);
-    });
-    test('--search-body presence = true, absence = false', async () => {
-        const present = await parseArgv(params, ['q', '--search-body']);
-        assert.equal(present['searchBody'], true);
-        const absent = await parseArgv(params, ['q']);
-        assert.equal(absent['searchBody'], false);
-    });
-    test('--scope all valid', async () => {
-        const r = await parseArgv(params, ['q', '--scope', 'all']);
-        assert.equal(r['scope'], 'all');
-    });
-});
-// ---------------------------------------------------------------------------
-// skill find grep
-// ---------------------------------------------------------------------------
-describe('skill find grep params', () => {
-    const params = [
-        { kind: 'positional', name: 'pattern', required: true, constraint: '' },
-        scopeAllFlag,
-        pluginFlag,
-    ];
-    test('pattern positional required', async () => {
-        await assert.rejects(() => parseArgv(params, []), (e) => { assert.match(e.message, /required parameter is missing/); return true; });
-    });
-    test('pattern parsed as positional', async () => {
-        const r = await parseArgv(params, ['foo.*bar']);
-        assert.equal(r['pattern'], 'foo.*bar');
-    });
-    test('pattern + scope + plugin', async () => {
-        const r = await parseArgv(params, ['\\btest\\b', '--scope', 'user', '--plugin', 'myplugin']);
-        assert.equal(r['pattern'], '\\btest\\b');
-        assert.equal(r['scope'], 'user');
-        assert.equal(r['plugin'], 'myplugin');
-    });
-});
-// ---------------------------------------------------------------------------
-// skill read
-// ---------------------------------------------------------------------------
-describe('skill read params', () => {
-    const params = [
-        { kind: 'positional', name: 'name', required: true, constraint: '' },
-        scopeWriteFlag,
-        pluginFlag,
-        { kind: 'flag', name: 'frontmatter', type: 'bool', required: false, constraint: '' },
-        { kind: 'flag', name: 'no-body', type: 'bool', required: false, constraint: '' },
-    ];
-    test('name positional required', async () => {
-        await assert.rejects(() => parseArgv(params, []), (e) => { assert.match(e.message, /required parameter is missing/); return true; });
-    });
-    test('name parsed correctly', async () => {
-        const r = await parseArgv(params, ['my-skill']);
-        assert.equal(r['name'], 'my-skill');
-    });
-    test('nested name parsed correctly', async () => {
-        const r = await parseArgv(params, ['some/nested/skill']);
-        assert.equal(r['name'], 'some/nested/skill');
-    });
-    test('--frontmatter presence = true', async () => {
-        const r = await parseArgv(params, ['my-skill', '--frontmatter']);
-        assert.equal(r['frontmatter'], true);
-    });
-    test('--frontmatter absent = false', async () => {
-        const r = await parseArgv(params, ['my-skill']);
-        assert.equal(r['frontmatter'], false);
-    });
-    test('--no-body presence = true (kebab to camelCase key)', async () => {
-        const r = await parseArgv(params, ['my-skill', '--no-body']);
-        assert.equal(r['noBody'], true);
-    });
-    test('--no-body absent = false', async () => {
-        const r = await parseArgv(params, ['my-skill']);
-        assert.equal(r['noBody'], false);
-    });
-    test('--scope rejects all', async () => {
-        await assert.rejects(() => parseArgv(params, ['my-skill', '--scope', 'all']), (e) => { assert.match(e.message, /must be one of/); return true; });
-    });
-    test('--scope user valid', async () => {
-        const r = await parseArgv(params, ['my-skill', '--scope', 'user']);
-        assert.equal(r['scope'], 'user');
-    });
-    test('--scope project valid', async () => {
-        const r = await parseArgv(params, ['skillname', '--scope', 'project']);
-        assert.equal(r['scope'], 'project');
-    });
-});
-// ---------------------------------------------------------------------------
-// skill author guide
-// ---------------------------------------------------------------------------
-describe('skill author guide params', () => {
-    const VALID_TYPES = ['playbook', 'primer', 'reference', 'runbook', 'freeform'];
-    const params = [
-        { kind: 'flag', name: 'type', type: 'enum', choices: VALID_TYPES, required: false, constraint: '' },
-        { kind: 'flag', name: 'topic', type: 'string', required: false, constraint: '' },
-    ];
-    test('no args: both undefined', async () => {
-        const r = await parseArgv(params, []);
-        assert.equal(r['type'], undefined);
-        assert.equal(r['topic'], undefined);
-    });
-    test('--type playbook', async () => {
-        const r = await parseArgv(params, ['--type', 'playbook']);
-        assert.equal(r['type'], 'playbook');
-    });
-    test('--type invalid rejects', async () => {
-        await assert.rejects(() => parseArgv(params, ['--type', 'bogus']), (e) => { assert.match(e.message, /must be one of/); return true; });
-    });
-    test('all valid types accepted', async () => {
-        for (const t of VALID_TYPES) {
-            const r = await parseArgv(params, ['--type', t]);
-            assert.equal(r['type'], t);
-        }
-    });
-    test('--topic string', async () => {
-        const r = await parseArgv(params, ['--topic', 'debugging methodology']);
-        assert.equal(r['topic'], 'debugging methodology');
-    });
-});
-// ---------------------------------------------------------------------------
-// skill author scaffold
-// ---------------------------------------------------------------------------
-describe('skill author scaffold params', () => {
-    const VALID_TYPES = ['playbook', 'primer', 'reference', 'runbook', 'freeform'];
-    const params = [
-        { kind: 'positional', name: 'qualifier', required: true, constraint: '' },
-        { kind: 'flag', name: 'type', type: 'enum', choices: VALID_TYPES, required: false, constraint: '' },
-        { kind: 'flag', name: 'description', type: 'string', required: false, constraint: '' },
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: '' },
-    ];
-    test('qualifier positional required', async () => {
-        await assert.rejects(() => parseArgv(params, []), (e) => { assert.match(e.message, /required parameter is missing/); return true; });
-    });
-    test('qualifier parsed correctly', async () => {
-        const r = await parseArgv(params, ['myplugin/myskill']);
-        assert.equal(r['qualifier'], 'myplugin/myskill');
-    });
-    test('full invocation', async () => {
-        const r = await parseArgv(params, [
-            'myplugin/myskill',
-            '--type', 'playbook',
-            '--scope', 'project',
-            '--description', 'Use when debugging',
-        ]);
-        assert.equal(r['qualifier'], 'myplugin/myskill');
-        assert.equal(r['type'], 'playbook');
-        assert.equal(r['scope'], 'project');
-        assert.equal(r['description'], 'Use when debugging');
-    });
-    test('--type invalid rejects', async () => {
-        await assert.rejects(() => parseArgv(params, ['q/s', '--type', 'invalid']), (e) => { assert.match(e.message, /must be one of/); return true; });
-    });
-    test('--scope all rejects', async () => {
-        await assert.rejects(() => parseArgv(params, ['q/s', '--scope', 'all']), (e) => { assert.match(e.message, /must be one of/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// skill state enable / disable
-// ---------------------------------------------------------------------------
-describe('skill state enable/disable params', () => {
-    const params = [
-        { kind: 'positional', name: 'name', required: true, constraint: '' },
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: '' },
-    ];
-    test('name positional required', async () => {
-        await assert.rejects(() => parseArgv(params, []), (e) => { assert.match(e.message, /required parameter is missing/); return true; });
-    });
-    test('name parsed correctly', async () => {
-        const r = await parseArgv(params, ['my-skill']);
-        assert.equal(r['name'], 'my-skill');
-    });
-    test('--scope user', async () => {
-        const r = await parseArgv(params, ['my-skill', '--scope', 'user']);
-        assert.equal(r['scope'], 'user');
-    });
-    test('--scope project', async () => {
-        const r = await parseArgv(params, ['my-skill', '--scope', 'project']);
-        assert.equal(r['scope'], 'project');
-    });
-    test('--scope all rejects', async () => {
-        await assert.rejects(() => parseArgv(params, ['my-skill', '--scope', 'all']), (e) => { assert.match(e.message, /must be one of/); return true; });
-    });
-    test('plugin/skill qualifier as name', async () => {
-        const r = await parseArgv(params, ['myplugin/myskill']);
-        assert.equal(r['name'], 'myplugin/myskill');
-    });
-});

package/dist/core/__tests__/pkg.test.js

@@ -1,218 +0,0 @@
-// Tests for the pkg subtree argv migration.
-// Exercises parseArgv against the param schemas declared in pkg.ts leaves.
-// No subprocess spawning; no real FS writes. Tests are schema/parsing level only.
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { parseArgv } from '../command.js';
-// ---------------------------------------------------------------------------
-// plugin manage install — positional source + optional flags
-// ---------------------------------------------------------------------------
-describe('pkg plugin manage install', () => {
-    const params = [
-        { kind: 'positional', name: 'source', type: 'string', required: true, constraint: 'Git URL.' },
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: '' },
-        { kind: 'flag', name: 'ref', type: 'string', required: false, constraint: '' },
-    ];
-    test('positional source is required', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('parses positional source', async () => {
-        const result = await parseArgv(params, ['https://github.com/org/my-plugin.git']);
-        assert.equal(result['source'], 'https://github.com/org/my-plugin.git');
-    });
-    test('parses positional source with --scope flag', async () => {
-        const result = await parseArgv(params, ['https://github.com/org/repo.git', '--scope', 'user']);
-        assert.equal(result['source'], 'https://github.com/org/repo.git');
-        assert.equal(result['scope'], 'user');
-    });
-    test('parses --ref flag', async () => {
-        const result = await parseArgv(params, ['https://example.com/repo.git', '--ref', 'v1.2.3']);
-        assert.equal(result['ref'], 'v1.2.3');
-    });
-    test('rejects invalid scope enum', async () => {
-        await assert.rejects(() => parseArgv(params, ['https://example.com/repo.git', '--scope', 'all']), (err) => { assert.match(err.message, /must be one of/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// plugin manage remove / enable / disable — positional name + optional scope
-// ---------------------------------------------------------------------------
-describe('pkg plugin manage remove/enable/disable', () => {
-    const params = [
-        { kind: 'positional', name: 'name', type: 'string', required: true, constraint: 'Plugin name.' },
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: '' },
-    ];
-    test('parses positional name', async () => {
-        const result = await parseArgv(params, ['my-plugin']);
-        assert.equal(result['name'], 'my-plugin');
-    });
-    test('parses name with scope', async () => {
-        const result = await parseArgv(params, ['my-plugin', '--scope', 'project']);
-        assert.equal(result['name'], 'my-plugin');
-        assert.equal(result['scope'], 'project');
-    });
-    test('missing name throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(params, ['--scope', 'user']), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// plugin manage update — optional --name flag
-// ---------------------------------------------------------------------------
-describe('pkg plugin manage update', () => {
-    const params = [
-        { kind: 'flag', name: 'name', type: 'string', required: false, constraint: '' },
-    ];
-    test('no args is valid (update-all path)', async () => {
-        const result = await parseArgv(params, []);
-        assert.equal(result['name'], undefined);
-    });
-    test('--name sets the name', async () => {
-        const result = await parseArgv(params, ['--name', 'my-plugin']);
-        assert.equal(result['name'], 'my-plugin');
-    });
-});
-// ---------------------------------------------------------------------------
-// plugin inspect list — --include-disabled bool flag + pagination
-// ---------------------------------------------------------------------------
-describe('pkg plugin inspect list', () => {
-    const params = [
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: '' },
-        { kind: 'flag', name: 'include-disabled', type: 'bool', required: false, constraint: '' },
-        { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: '' },
-        { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: '' },
-    ];
-    test('no args returns defaults', async () => {
-        const result = await parseArgv(params, []);
-        assert.equal(result['includeDisabled'], false);
-        assert.equal(result['limit'], 50);
-        assert.equal(result['scope'], undefined);
-        assert.equal(result['cursor'], undefined);
-    });
-    test('--include-disabled presence sets true', async () => {
-        const result = await parseArgv(params, ['--include-disabled']);
-        assert.equal(result['includeDisabled'], true);
-    });
-    test('--include-disabled camelCase key', async () => {
-        const result = await parseArgv(params, ['--include-disabled']);
-        assert.ok('includeDisabled' in result);
-        assert.ok(!('include-disabled' in result));
-    });
-    test('--limit parsed as int', async () => {
-        const result = await parseArgv(params, ['--limit', '25']);
-        assert.equal(result['limit'], 25);
-    });
-    test('--cursor passed through', async () => {
-        const result = await parseArgv(params, ['--cursor', 'user:some-plugin']);
-        assert.equal(result['cursor'], 'user:some-plugin');
-    });
-    test('--scope all is valid', async () => {
-        const result = await parseArgv(params, ['--scope', 'all']);
-        assert.equal(result['scope'], 'all');
-    });
-});
-// ---------------------------------------------------------------------------
-// plugin inspect show — positional name
-// ---------------------------------------------------------------------------
-describe('pkg plugin inspect show', () => {
-    const params = [
-        { kind: 'positional', name: 'name', type: 'string', required: true, constraint: 'Plugin name.' },
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: '' },
-    ];
-    test('parses positional name', async () => {
-        const result = await parseArgv(params, ['my-plugin']);
-        assert.equal(result['name'], 'my-plugin');
-    });
-    test('missing name throws', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// market manage install — --marketplace + --plugin required flags
-// ---------------------------------------------------------------------------
-describe('pkg market manage install', () => {
-    const params = [
-        { kind: 'flag', name: 'marketplace', type: 'string', required: true, constraint: '' },
-        { kind: 'flag', name: 'plugin', type: 'string', required: true, constraint: '' },
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: '' },
-    ];
-    test('parses --marketplace and --plugin together', async () => {
-        const result = await parseArgv(params, ['--marketplace', 'official', '--plugin', 'my-plugin']);
-        assert.equal(result['marketplace'], 'official');
-        assert.equal(result['plugin'], 'my-plugin');
-    });
-    test('missing --marketplace throws', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plugin', 'my-plugin']), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('missing --plugin throws', async () => {
-        await assert.rejects(() => parseArgv(params, ['--marketplace', 'official']), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('parses all three flags', async () => {
-        const result = await parseArgv(params, ['--marketplace', 'official', '--plugin', 'my-plugin', '--scope', 'user']);
-        assert.equal(result['marketplace'], 'official');
-        assert.equal(result['plugin'], 'my-plugin');
-        assert.equal(result['scope'], 'user');
-    });
-});
-// ---------------------------------------------------------------------------
-// market manage update — optional --marketplace flag
-// ---------------------------------------------------------------------------
-describe('pkg market manage update', () => {
-    const params = [
-        { kind: 'flag', name: 'marketplace', type: 'string', required: false, constraint: '' },
-    ];
-    test('no args is valid (update-all path)', async () => {
-        const result = await parseArgv(params, []);
-        assert.equal(result['marketplace'], undefined);
-    });
-    test('--marketplace sets name', async () => {
-        const result = await parseArgv(params, ['--marketplace', 'official']);
-        assert.equal(result['marketplace'], 'official');
-    });
-});
-// ---------------------------------------------------------------------------
-// market manage remove — positional name
-// ---------------------------------------------------------------------------
-describe('pkg market manage remove', () => {
-    const params = [
-        { kind: 'positional', name: 'name', type: 'string', required: true, constraint: '' },
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: '' },
-    ];
-    test('parses positional name', async () => {
-        const result = await parseArgv(params, ['official']);
-        assert.equal(result['name'], 'official');
-    });
-});
-// ---------------------------------------------------------------------------
-// market inspect list / browse — pagination flags
-// ---------------------------------------------------------------------------
-describe('pkg market inspect list pagination', () => {
-    const params = [
-        { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: '' },
-        { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: '' },
-        { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: '' },
-    ];
-    test('default limit is 50', async () => {
-        const result = await parseArgv(params, []);
-        assert.equal(result['limit'], 50);
-    });
-    test('--limit and --cursor parsed together', async () => {
-        const result = await parseArgv(params, ['--limit', '10', '--cursor', 'tok123']);
-        assert.equal(result['limit'], 10);
-        assert.equal(result['cursor'], 'tok123');
-    });
-});
-describe('pkg market inspect browse', () => {
-    const params = [
-        { kind: 'flag', name: 'marketplace', type: 'string', required: false, constraint: '' },
-        { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: '' },
-        { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: '' },
-    ];
-    test('--marketplace optional', async () => {
-        const result = await parseArgv(params, []);
-        assert.equal(result['marketplace'], undefined);
-    });
-    test('--marketplace with pagination', async () => {
-        const result = await parseArgv(params, ['--marketplace', 'official', '--limit', '20']);
-        assert.equal(result['marketplace'], 'official');
-        assert.equal(result['limit'], 20);
-    });
-});