@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/clients/attach/__tests__/onrequest-wired.test.js

@@ -1,20 +0,0 @@
-// Regression: the `crtr attach` viewer built its InputController WITHOUT the
-// `onRequest` hook, so the correlated read-op channel was never wired even
-// though ViewSocketClient.request() was fully implemented. Every native picker
-// (/model, /resume, /fork, /tree, /settings, /scoped-models) therefore degraded
-// to the "isn't available in this viewer" notice — /model couldn't open the
-// model picker. The fix wires `onRequest: (frame) => socket.request(frame)` in
-// attach-cmd. This assembly lives inside a big TUI-constructing function with no
-// seam to unit-test, so this guards the exact wiring at the source level.
-// See src/clients/attach/{attach-cmd,input-controller,slash-commands}.ts.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-const src = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'attach-cmd.ts'), 'utf8');
-test('attach-cmd wires onRequest to socket.request so native pickers work', () => {
-    // The InputController must receive the read-op channel; without it
-    // openPicker() short-circuits to the "isn't available in this viewer" notice.
-    assert.match(src.replace(/\s+/g, ' '), /onRequest:\s*\(frame\)\s*=>\s*socket\.request\(frame\)/, 'attach-cmd must pass onRequest: (frame) => socket.request(frame) to InputController');
-});

package/dist/clients/attach/__tests__/reconnect-giveup.test.js

@@ -1,30 +0,0 @@
-// Regression: the `crtr attach` viewer used to ALWAYS teardown ("broker gone")
-// on a socket close, so a resident broker node's yield→revive cycle dropped the
-// viewer to a shell. The fix holds the pane and re-dials the SAME view.sock
-// while the node is still alive, giving up only when it is genuinely gone. This
-// locks the give-up/keep-reconnecting decision (the bug-prone core) without a
-// socket or tmux. See src/clients/attach/{view-socket,attach-cmd}.ts.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { reconnectShouldGiveUp } from '../view-socket.js';
-const rowWith = (status) => ({
-    node_id: 'n',
-    status,
-    host_kind: 'broker',
-    intent: null,
-    pi_pid: null,
-});
-test('keeps reconnecting while the node is still alive (active = mid yield/revive)', () => {
-    // A yield leaves status='active' (intent='refresh') — must NOT give up.
-    assert.equal(reconnectShouldGiveUp(rowWith('active')), false);
-    // idle-release revives on the next inbox wake — keep trying (bounded by the
-    // supervisor's own ~30s deadline), do not give up.
-    assert.equal(reconnectShouldGiveUp(rowWith('idle')), false);
-});
-test('gives up the instant the node is genuinely gone', () => {
-    assert.equal(reconnectShouldGiveUp(rowWith('done')), true);
-    assert.equal(reconnectShouldGiveUp(rowWith('dead')), true);
-    assert.equal(reconnectShouldGiveUp(rowWith('canceled')), true);
-    // A reaped row (null) → give up.
-    assert.equal(reconnectShouldGiveUp(null), true);
-});

package/dist/clients/attach/__tests__/slash-quit-copy.test.js

@@ -1,42 +0,0 @@
-// Regression: `/quit` in the attach viewer only sent a `bye` frame + a notice.
-// The broker answers `bye` with socket.end(), which the viewer's close handler
-// treats as a dropped connection and RECONNECTS — so `/quit` never detached (it
-// silently reconnected). The fix routes `/quit` through an `onQuit` hook wired to
-// teardown('detach'). Likewise `/copy` was a dead "not available" stub; it now
-// runs through an `onCopy` hook. This guards the dispatch contract for both.
-// See src/clients/attach/{slash-commands,input-controller,attach-cmd}.ts.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { dispatchSlashCommand } from '../slash-commands.js';
-function ctx(overrides = {}) {
-    const sent = [];
-    const notices = [];
-    return {
-        send: (f) => sent.push(f),
-        notify: (m) => notices.push(m),
-        sent,
-        notices,
-        ...overrides,
-    };
-}
-test('/quit detaches via onQuit and does NOT send a bare bye (reconnect-loop bug)', () => {
-    let quit = 0;
-    const c = ctx({ onQuit: () => quit++ });
-    const handled = dispatchSlashCommand('/quit', c);
-    assert.equal(handled, true);
-    assert.equal(quit, 1, '/quit must invoke onQuit (teardown), not just send bye');
-    assert.equal(c.sent.length, 0, '/quit must not send a bare bye frame when onQuit is wired');
-});
-test('/quit falls back to a bye frame when onQuit is unwired', () => {
-    const c = ctx();
-    dispatchSlashCommand('/quit', c);
-    assert.deepEqual(c.sent, [{ type: 'bye' }]);
-});
-test('/copy runs through onCopy instead of the dead "not available" stub', () => {
-    let copy = 0;
-    const c = ctx({ onCopy: () => copy++ });
-    const handled = dispatchSlashCommand('/copy', c);
-    assert.equal(handled, true);
-    assert.equal(copy, 1, '/copy must invoke onCopy');
-    assert.equal(c.notices.length, 0, '/copy must not fall through to a notice when onCopy is wired');
-});

package/dist/clients/attach/__tests__/titled-editor.test.js

@@ -1,39 +0,0 @@
-// Regression: TitledEditor's top border dropped the git-info chip only when the
-// title chip left fewer than 4 free columns — when BOTH chips fit individually
-// but their sum exceeded the terminal width, the fill clamped to 0 and the line
-// came out chipW+infoW wide. pi-tui hard-crashes on any over-wide line:
-//   "Error: Rendered line 3192 exceeds terminal width (75 > 70)"
-// (title chip " ⬢ general (base) continue-crouter-development 0 " = 50 cols,
-// info "crouter · ⎇ main · ●⇡5⇣1" = 25 cols, terminal 70). The fix truncates
-// the info chip to the space the title leaves instead of all-or-nothing.
-// See composeTopBorder in src/clients/attach/titled-editor.ts.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { visibleWidth } from '@earendil-works/pi-tui';
-import { composeTopBorder } from '../titled-editor.js';
-const titleStyle = (s) => `\x1b[7m ${s} \x1b[27m`;
-const borderColor = (s) => `\x1b[38;2;128;128;128m${s}\x1b[39m`;
-const compose = (width, title, info) => composeTopBorder(width, title, info, titleStyle, borderColor);
-test('crash scenario: chip + info that each fit but overflow together stays at width', () => {
-    const title = '⬢ general (base) continue-crouter-development 0'; // chip = 50 cols
-    const info = `\x1b[38;2;128;128;128mcrouter · \x1b[39m\x1b[38;2;129;162;190m⎇ main\x1b[39m\x1b[38;2;128;128;128m · \x1b[39m\x1b[33m●\x1b[39m⇡5⇣1`; // 25 cols
-    const line = compose(70, title, info);
-    assert.equal(visibleWidth(line), 70, 'line must be exactly terminal width, not 75');
-});
-test('top border never exceeds width across title/info length combinations', () => {
-    const longInfo = `\x1b[33m${'status-info-'.repeat(8)}\x1b[39m`;
-    for (const width of [20, 40, 70, 120]) {
-        for (const title of ['', 'a', 'session', 'x'.repeat(200)]) {
-            for (const info of ['', 'crouter · main', longInfo]) {
-                const line = compose(width, title, info);
-                assert.ok(visibleWidth(line) <= width, `overflow at width=${width} titleLen=${title.length} infoW=${visibleWidth(info)}: got ${visibleWidth(line)}`);
-            }
-        }
-    }
-});
-test('info chip survives intact when there is room for it', () => {
-    const info = 'crouter · main';
-    const line = compose(80, 'sess', info);
-    assert.ok(line.includes(info), 'fitting info must not be truncated or dropped');
-    assert.equal(visibleWidth(line), 80);
-});

package/dist/commands/memory/__tests__/lint-schema.test.js

@@ -1,52 +0,0 @@
-// Bug-regression: guards the hard cut that merged the substrate's `when`/`why`
-// frontmatter pair into the single `when-and-why-to-read` read-routing field.
-// The CTO ruling (taste/why-field-means-why-to-read) requires the migration be
-// a hard cut: an old-shape doc must FAIL at `crtr memory lint`, never be read at
-// runtime. `lintSubstrateSchema` is that enforcement seam — these lock it.
-//
-// Run: node --import tsx/esm --test src/commands/memory/__tests__/lint-schema.test.ts
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { lintSubstrateSchema } from '../lint.js';
-const ROUTING = 'When you are X, this reference should be read because Y';
-const RUNGS = { 'system-prompt-visibility': 'name', 'file-read-visibility': 'none' };
-test('lint rejects a doc still carrying the retired `when` key', () => {
-    const err = lintSubstrateSchema({ kind: 'knowledge', when: 'when X' });
-    assert.ok(err !== null, 'old-shape `when` must produce a finding');
-    assert.match(err, /when-and-why-to-read/, 'the message points at the new field');
-});
-test('lint rejects a doc still carrying the retired `why` key', () => {
-    const err = lintSubstrateSchema({ kind: 'knowledge', why: 'because Y' });
-    assert.ok(err !== null, 'old-shape `why` must produce a finding');
-    assert.match(err, /when-and-why-to-read/, 'the message points at the new field');
-});
-test('lint rejects a substrate doc missing the merged routing field', () => {
-    const err = lintSubstrateSchema({ kind: 'knowledge' });
-    assert.ok(err !== null, 'a substrate doc must carry when-and-why-to-read');
-    assert.match(err, /when-and-why-to-read/);
-});
-test('lint accepts the merged new-shape frontmatter', () => {
-    assert.equal(lintSubstrateSchema({ kind: 'knowledge', 'when-and-why-to-read': ROUTING, ...RUNGS }), null);
-});
-// Visibility is a required, case-by-case authoring call — there is no kind
-// default. lint must reject a doc that omits either rung (the runtime parser
-// silently floors a missing rung to `none`, which is exactly the tolerance this
-// gate exists to catch at authoring time).
-test('lint rejects a substrate doc missing system-prompt-visibility', () => {
-    const err = lintSubstrateSchema({
-        kind: 'knowledge',
-        'when-and-why-to-read': ROUTING,
-        'file-read-visibility': 'none',
-    });
-    assert.ok(err !== null, 'a missing rung must produce a finding');
-    assert.match(err, /missing system-prompt-visibility/);
-});
-test('lint rejects a substrate doc missing file-read-visibility', () => {
-    const err = lintSubstrateSchema({
-        kind: 'knowledge',
-        'when-and-why-to-read': ROUTING,
-        'system-prompt-visibility': 'name',
-    });
-    assert.ok(err !== null, 'a missing rung must produce a finding');
-    assert.match(err, /missing file-read-visibility/);
-});

package/dist/core/__tests__/argv-parser.test.js

@@ -1,217 +0,0 @@
-// Framework tests for the argv parser and help renderer (inputModel: 'argv').
-// Run with: node --import tsx/esm --test src/core/__tests__/argv-parser.test.ts
-// These tests exercise parseArgv and renderLeafArgv directly — no process.argv
-// mutation, no subprocess spawning.
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import { parseArgv } from '../command.js';
-import { renderLeafArgv } from '../help.js';
-import { defineLeaf } from '../command.js';
-// ---------------------------------------------------------------------------
-// parseArgv — flags
-// ---------------------------------------------------------------------------
-describe('parseArgv: flags', () => {
-    const params = [
-        { kind: 'flag', name: 'plan-id', type: 'string', required: true, constraint: 'Plan id.' },
-        { kind: 'flag', name: 'limit', type: 'int', required: false, constraint: 'Max results.', default: 20 },
-        { kind: 'flag', name: 'follow', type: 'bool', required: false, constraint: 'Stream.' },
-        { kind: 'flag', name: 'status', type: 'enum', choices: ['draft', 'done'], required: false, constraint: 'Filter.' },
-    ];
-    test('parses --flag value form', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'abc123']);
-        assert.equal(result['planId'], 'abc123');
-    });
-    test('parses --flag=value form', async () => {
-        const result = await parseArgv(params, ['--plan-id=abc123']);
-        assert.equal(result['planId'], 'abc123');
-    });
-    test('parses int flag', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x', '--limit', '42']);
-        assert.equal(result['limit'], 42);
-    });
-    test('rejects non-integer for int flag', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--limit', 'notanint']), (err) => { assert.match(err.message, /must be an integer/); return true; });
-    });
-    test('bool flag: presence = true', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x', '--follow']);
-        assert.equal(result['follow'], true);
-    });
-    test('bool flag: absence = default false', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x']);
-        assert.equal(result['follow'], false);
-    });
-    test('bool flag rejects --flag=value', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--follow=true']), (err) => { assert.match(err.message, /takes no value/); return true; });
-    });
-    test('enum flag: valid value passes', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x', '--status', 'draft']);
-        assert.equal(result['status'], 'draft');
-    });
-    test('enum flag: invalid value throws invalid_type', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--status', 'unknown']), (err) => { assert.match(err.message, /must be one of/); return true; });
-    });
-    test('int flag default applied when absent', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'x']);
-        assert.equal(result['limit'], 20);
-    });
-    test('unknown flag throws unknown_flag', async () => {
-        await assert.rejects(() => parseArgv(params, ['--plan-id', 'x', '--bogus', 'y']), (err) => { assert.match(err.message, /unknown flag/); return true; });
-    });
-    test('missing required flag throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('kebab-case flag name becomes camelCase key', async () => {
-        const result = await parseArgv(params, ['--plan-id', 'abc']);
-        assert.ok('planId' in result);
-        assert.ok(!('plan-id' in result));
-    });
-});
-// ---------------------------------------------------------------------------
-// parseArgv — positional
-// ---------------------------------------------------------------------------
-describe('parseArgv: positional', () => {
-    const params = [
-        { kind: 'positional', name: 'job-id', required: true, constraint: 'Job id.' },
-        { kind: 'flag', name: 'follow', type: 'bool', required: false, constraint: '' },
-    ];
-    test('parses single positional before flags', async () => {
-        const result = await parseArgv(params, ['job-abc', '--follow']);
-        assert.equal(result['jobId'], 'job-abc');
-        assert.equal(result['follow'], true);
-    });
-    test('parses single positional after flags', async () => {
-        const result = await parseArgv(params, ['--follow', 'job-abc']);
-        assert.equal(result['jobId'], 'job-abc');
-    });
-    test('parses positional after bare --', async () => {
-        const result = await parseArgv(params, ['--', 'job-abc']);
-        assert.equal(result['jobId'], 'job-abc');
-    });
-    test('two positionals throws bad_invocation', async () => {
-        await assert.rejects(() => parseArgv(params, ['job-abc', 'extra']), (err) => { assert.match(err.message, /unexpected extra positional/); return true; });
-    });
-    test('missing required positional throws missing_parameter', async () => {
-        await assert.rejects(() => parseArgv(params, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
-    });
-    test('positional when none declared throws bad_invocation', async () => {
-        const noPos = [
-            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: '' },
-        ];
-        await assert.rejects(() => parseArgv(noPos, ['somevalue']), (err) => { assert.match(err.message, /takes no positional/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// parseArgv — stdin satisfied by a positional argument
-// ---------------------------------------------------------------------------
-describe('parseArgv: stdin-as-positional', () => {
-    const params = [
-        { kind: 'stdin', name: 'prompt', required: true, constraint: 'Task.' },
-        { kind: 'flag', name: 'agent', type: 'string', required: false, default: 'general', constraint: '' },
-    ];
-    test('a positional token satisfies a stdin param', async () => {
-        const result = await parseArgv(params, ['--agent', 'general', 'Say hi']);
-        assert.equal(result['prompt'], 'Say hi');
-        assert.equal(result['agent'], 'general');
-    });
-    test('positional-as-stdin works with the positional before flags', async () => {
-        const result = await parseArgv(params, ['Say hi', '--agent', 'general']);
-        assert.equal(result['prompt'], 'Say hi');
-    });
-});
-// ---------------------------------------------------------------------------
-// parseArgv — context-file
-// ---------------------------------------------------------------------------
-describe('parseArgv: context-file', () => {
-    test('unknown --context-file when not declared throws unknown_flag', async () => {
-        const params = [];
-        await assert.rejects(() => parseArgv(params, ['--context-file', '/some/path']), (err) => { assert.match(err.message, /unknown flag: --context-file/); return true; });
-    });
-    test('--context-file missing PATH throws missing_parameter', async () => {
-        const params = [
-            { kind: 'context-file', name: 'context', required: false, constraint: '' },
-        ];
-        await assert.rejects(() => parseArgv(params, ['--context-file']), (err) => { assert.match(err.message, /requires a PATH/); return true; });
-    });
-    test('--context-file with nonexistent file throws invalid_type', async () => {
-        const params = [
-            { kind: 'context-file', name: 'context', required: false, constraint: '' },
-        ];
-        await assert.rejects(() => parseArgv(params, ['--context-file', '/no/such/file/xyz.json']), (err) => { assert.match(err.message, /cannot read file/); return true; });
-    });
-});
-// ---------------------------------------------------------------------------
-// renderLeafArgv — help format
-// ---------------------------------------------------------------------------
-describe('renderLeafArgv: help format', () => {
-    const help = {
-        name: 'task claim',
-        summary: 'claim a draft task and spawn a worker',
-        params: [
-            { kind: 'positional', name: 'task-id', required: true, constraint: 'Task in draft state.' },
-            { kind: 'flag', name: 'worker', type: 'string', required: false, constraint: 'Worker template.' },
-            { kind: 'flag', name: 'follow', type: 'bool', required: false, constraint: 'Stream output.' },
-            { kind: 'context-file', name: 'context', required: false, constraint: 'Extra facts for the worker.', shape: '{key: string}' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Use with crtr job logs.' },
-        ],
-        outputKind: 'object',
-        effects: ['Marks task claimed.'],
-    };
-    test('starts with name: summary', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.startsWith('task claim: claim a draft task and spawn a worker.'));
-    });
-    test('contains Input section', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('Input'));
-    });
-    test('positional shown as TASK_ID', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('TASK-ID'));
-    });
-    test('bool flag shown without VALUE placeholder', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('--follow'));
-        assert.ok(!out.includes('--follow FOLLOW'));
-    });
-    test('string flag shown with VALUE placeholder', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('--worker WORKER'));
-    });
-    test('context-file shown as --context-file PATH', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('--context-file PATH'));
-    });
-    test('contains Output section', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('Output (fields carried in the rendered result)'));
-    });
-    test('contains Effects section', () => {
-        const out = renderLeafArgv(help);
-        assert.ok(out.includes('Effects'));
-        assert.ok(out.includes('Marks task claimed.'));
-    });
-});
-// ---------------------------------------------------------------------------
-// defineLeaf
-// ---------------------------------------------------------------------------
-describe('defineLeaf', () => {
-    test('builds a leaf with the declared params', () => {
-        const leaf = defineLeaf({
-            name: 'test',
-            help: {
-                name: 'test',
-                summary: 'test leaf',
-                params: [],
-                output: [],
-                outputKind: 'object',
-                effects: [],
-            },
-            run: async () => { },
-        });
-        assert.equal(leaf.kind, 'leaf');
-        assert.equal(leaf.name, 'test');
-        assert.deepEqual(leaf.help.params, []);
-    });
-});