relay-ide 0.1.0

package/dist/test/components/TuiInput.spec.js

@@ -0,0 +1,186 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+// Note: Full DOM testing would require a test runner with JSX support (e.g., Vitest + React Testing Library)
+describe('TuiInput', () => {
+    describe('Props Interface', () => {
+        it('should have optional value prop with default empty string', () => {
+            const propsWithoutValue = {};
+            assert.strictEqual(propsWithoutValue.value, undefined);
+            const propsWithValue = { value: 'test' };
+            assert.strictEqual(propsWithValue.value, 'test');
+        });
+        it('should have optional placeholder prop', () => {
+            const props = { placeholder: 'Enter text' };
+            assert.strictEqual(props.placeholder, 'Enter text');
+        });
+        it('should have type prop with text or password options', () => {
+            const textType = { type: 'text' };
+            assert.strictEqual(textType.type, 'text');
+            const passwordType = { type: 'password' };
+            assert.strictEqual(passwordType.type, 'password');
+        });
+        it('should have optional disabled prop', () => {
+            const propsWithDisabled = { disabled: true };
+            assert.strictEqual(propsWithDisabled.disabled, true);
+            const propsWithoutDisabled = {};
+            assert.strictEqual(propsWithoutDisabled.disabled, undefined);
+        });
+        it('should have optional id prop', () => {
+            const props = { id: 'my-input' };
+            assert.strictEqual(props.id, 'my-input');
+        });
+        it('should have optional onInput callback', () => {
+            let calledWith;
+            const handleInput = (e) => {
+                calledWith = e;
+            };
+            const props = { onInput: handleInput };
+            assert.strictEqual(typeof props.onInput, 'function');
+        });
+        it('should have optional onKeyDown callback', () => {
+            let calledWith;
+            const handleKeyDown = (e) => {
+                calledWith = e;
+            };
+            const props = { onKeyDown: handleKeyDown };
+            assert.strictEqual(typeof props.onKeyDown, 'function');
+        });
+        it('should have optional onChange callback', () => {
+            let calledWith;
+            const handleChange = (value) => {
+                calledWith = value;
+            };
+            const props = { onChange: handleChange };
+            assert.strictEqual(typeof props.onChange, 'function');
+            props.onChange?.('new value');
+            assert.strictEqual(calledWith, 'new value');
+        });
+        it('should have optional className prop', () => {
+            const props = { className: 'custom-class' };
+            assert.strictEqual(props.className, 'custom-class');
+        });
+        it('should have optional autoFocus prop', () => {
+            const propsWithAutoFocus = { autoFocus: true };
+            assert.strictEqual(propsWithAutoFocus.autoFocus, true);
+            const propsWithoutAutoFocus = {};
+            assert.strictEqual(propsWithoutAutoFocus.autoFocus, undefined);
+        });
+        it('should support rest props spread', () => {
+            const props = {
+                'data-testid': 'test-input',
+                'aria-label': 'Test input',
+                maxLength: 100
+            };
+            assert.strictEqual(props['data-testid'], 'test-input');
+            assert.strictEqual(props['aria-label'], 'Test input');
+            assert.strictEqual(props.maxLength, 100);
+        });
+    });
+    describe('Component Logic', () => {
+        it('should mask password input with bullet character', () => {
+            const type = 'password';
+            const value = 'secret';
+            const selStart = 3;
+            const textBeforeCursor = type === 'password'
+                ? '\u2022'.repeat(selStart)
+                : value.slice(0, selStart);
+            assert.strictEqual(textBeforeCursor, '\u2022\u2022\u2022');
+        });
+        it('should not mask text input', () => {
+            const type = 'text';
+            const value = 'hello';
+            const selStart = 3;
+            const textBeforeCursor = type === 'password'
+                ? '\u2022'.repeat(selStart)
+                : value.slice(0, selStart);
+            assert.strictEqual(textBeforeCursor, 'hel');
+        });
+        it('should apply idle timeout of 530ms', () => {
+            const IDLE_TIMEOUT = 530;
+            assert.strictEqual(IDLE_TIMEOUT, 530);
+        });
+        it('should show cursor when focused and not disabled', () => {
+            const isFocused = true;
+            const disabled = false;
+            const showCursor = isFocused && !disabled;
+            assert.strictEqual(showCursor, true);
+        });
+        it('should hide cursor when not focused', () => {
+            const isFocused = false;
+            const disabled = false;
+            const showCursor = isFocused && !disabled;
+            assert.strictEqual(showCursor, false);
+        });
+        it('should hide cursor when disabled', () => {
+            const isFocused = true;
+            const disabled = true;
+            const showCursor = isFocused && !disabled;
+            assert.strictEqual(showCursor, false);
+        });
+        it('should apply blinking class when idle and no reduced motion', () => {
+            const isIdle = true;
+            const prefersReducedMotion = false;
+            const shouldBlink = isIdle && !prefersReducedMotion;
+            assert.strictEqual(shouldBlink, true);
+        });
+        it('should not blink when reduced motion is preferred', () => {
+            const isIdle = true;
+            const prefersReducedMotion = true;
+            const shouldBlink = isIdle && !prefersReducedMotion;
+            assert.strictEqual(shouldBlink, false);
+        });
+        it('should not blink when not idle', () => {
+            const isIdle = false;
+            const prefersReducedMotion = false;
+            const shouldBlink = isIdle && !prefersReducedMotion;
+            assert.strictEqual(shouldBlink, false);
+        });
+    });
+    describe('CSS Classes', () => {
+        it('should have correct base classes', () => {
+            const expectedClasses = {
+                wrapper: 'tui-input-wrapper',
+                input: 'tui-input',
+                measure: 'tui-measure',
+                cursor: 'tui-cursor',
+                blinking: 'blinking'
+            };
+            assert.strictEqual(expectedClasses.wrapper, 'tui-input-wrapper');
+            assert.strictEqual(expectedClasses.input, 'tui-input');
+            assert.strictEqual(expectedClasses.measure, 'tui-measure');
+            assert.strictEqual(expectedClasses.cursor, 'tui-cursor');
+            assert.strictEqual(expectedClasses.blinking, 'blinking');
+        });
+        it('should combine custom className with base wrapper class', () => {
+            const className = 'custom-class';
+            const classes = ['tui-input-wrapper', className].filter(Boolean).join(' ');
+            assert.strictEqual(classes, 'tui-input-wrapper custom-class');
+        });
+    });
+    describe('Cursor Position Calculation', () => {
+        it('should use block cursor character', () => {
+            const blockCursor = '\u2588';
+            assert.strictEqual(blockCursor, '\u2588');
+        });
+        it('should default cursor height to 16 when input height is 0', () => {
+            const inputHeight = 0;
+            const cursorHeight = inputHeight || 16;
+            assert.strictEqual(cursorHeight, 16);
+        });
+        it('should use input height when available', () => {
+            const inputHeight = 24;
+            const cursorHeight = inputHeight || 16;
+            assert.strictEqual(cursorHeight, 24);
+        });
+    });
+    describe('Accessibility', () => {
+        it('should mark measure span as aria-hidden', () => {
+            const ariaHidden = true;
+            assert.strictEqual(ariaHidden, true);
+        });
+        it('should mark cursor span as aria-hidden', () => {
+            const ariaHidden = true;
+            assert.strictEqual(ariaHidden, true);
+        });
+    });
+});

package/dist/test/components/leaf-component-migration.spec.js

@@ -0,0 +1,104 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, '../..');
+const expectedComponents = [
+    {
+        name: 'AgentBadge',
+        componentPath: 'frontend/src/components/AgentBadge.tsx',
+        cssPath: 'frontend/src/components/AgentBadge.css',
+        expectedExports: ['export interface AgentBadgeProps', 'export function AgentBadge'],
+    },
+    {
+        name: 'DiffFileSidebar',
+        componentPath: 'frontend/src/components/DiffFileSidebar.tsx',
+        cssPath: 'frontend/src/components/DiffFileSidebar.css',
+        expectedExports: ['export interface DiffFileSidebarProps', 'export const DiffFileSidebar'],
+    },
+    {
+        name: 'DiffSourceToggle',
+        componentPath: 'frontend/src/components/DiffSourceToggle.tsx',
+        cssPath: 'frontend/src/components/DiffSourceToggle.css',
+        expectedExports: ['export interface DiffSourceToggleProps', 'export function DiffSourceToggle'],
+    },
+    {
+        name: 'FilterChipBar',
+        componentPath: 'frontend/src/components/FilterChipBar.tsx',
+        cssPath: 'frontend/src/components/FilterChipBar.css',
+        expectedExports: ['export interface FilterChip', 'export function FilterChipBar'],
+    },
+    {
+        name: 'MobileHeader',
+        componentPath: 'frontend/src/components/MobileHeader.tsx',
+        cssPath: 'frontend/src/components/MobileHeader.css',
+        expectedExports: ['export interface MobileHeaderProps', 'export function MobileHeader'],
+    },
+    {
+        name: 'TuiMenuItem',
+        componentPath: 'frontend/src/components/TuiMenuItem.tsx',
+        cssPath: 'frontend/src/components/TuiMenuItem.css',
+        expectedExports: ['export interface TuiMenuItemProps', 'export function TuiMenuItem'],
+    },
+    {
+        name: 'TuiMenuPanel',
+        componentPath: 'frontend/src/components/TuiMenuPanel.tsx',
+        cssPath: 'frontend/src/components/TuiMenuPanel.css',
+        expectedExports: ['export interface TuiMenuPanelProps', 'export function TuiMenuPanel'],
+    },
+    {
+        name: 'TuiProgress',
+        componentPath: 'frontend/src/components/TuiProgress.tsx',
+        cssPath: 'frontend/src/components/TuiProgress.css',
+        expectedExports: ['export interface TuiProgressProps', 'export function TuiProgress'],
+    },
+    {
+        name: 'TuiRow',
+        componentPath: 'frontend/src/components/TuiRow.tsx',
+        cssPath: 'frontend/src/components/TuiRow.css',
+        expectedExports: ['export interface TuiRowProps', 'export function TuiRow'],
+    },
+    {
+        name: 'DialogShell',
+        componentPath: 'frontend/src/components/dialogs/DialogShell.tsx',
+        cssPath: 'frontend/src/components/dialogs/DialogShell.css',
+        expectedExports: ['export interface DialogShellHandle', 'export const DialogShell'],
+    },
+    {
+        name: 'SettingRow',
+        componentPath: 'frontend/src/components/dialogs/SettingRow.tsx',
+        cssPath: 'frontend/src/components/dialogs/SettingRow.css',
+        expectedExports: ['export interface SettingRowProps', 'export function SettingRow'],
+    },
+    {
+        name: 'SettingsToc',
+        componentPath: 'frontend/src/components/dialogs/SettingsToc.tsx',
+        cssPath: 'frontend/src/components/dialogs/SettingsToc.css',
+        expectedExports: ['export interface SettingsTocSection', 'export function SettingsToc'],
+    },
+];
+describe('leaf component migration', () => {
+    for (const component of expectedComponents) {
+        it(`${component.name} TSX and CSS files exist`, () => {
+            assert.ok(existsSync(join(projectRoot, component.componentPath)), `${component.componentPath} should exist`);
+            assert.ok(existsSync(join(projectRoot, component.cssPath)), `${component.cssPath} should exist`);
+        });
+        it(`${component.name} exports the expected component API`, () => {
+            const source = readFileSync(join(projectRoot, component.componentPath), 'utf8');
+            for (const expectedExport of component.expectedExports) {
+                assert.ok(source.includes(expectedExport), `${component.name} should include "${expectedExport}"`);
+            }
+            assert.ok(source.includes('export default'), `${component.name} should have a default export`);
+        });
+        it(`${component.name} imports its CSS file`, () => {
+            const source = readFileSync(join(projectRoot, component.componentPath), 'utf8');
+            const cssFileName = component.cssPath.split('/').pop();
+            assert.ok(source.includes(`import './${cssFileName}'`) ||
+                source.includes(`import '../${cssFileName}'`) ||
+                source.includes(`import '../../${cssFileName}'`), `${component.name} should import ${cssFileName}`);
+        });
+    }
+});

package/dist/test/config-freshness.test.js

@@ -0,0 +1,63 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadConfig, saveConfig, DEFAULTS } from '../server/config.js';
+describe('config freshness', () => {
+    let tmpDir;
+    let configPath;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'crc-config-test-'));
+        configPath = path.join(tmpDir, 'config.json');
+        const initial = { ...DEFAULTS, configVersion: 4 };
+        initial.repos = ['/existing/workspace'];
+        fs.writeFileSync(configPath, JSON.stringify(initial, null, 2));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('loadConfig sees repos added to disk after initial load', () => {
+        // Simulate: server starts, loads config
+        const initial = loadConfig(configPath);
+        assert.deepEqual(initial.repos, ['/existing/workspace']);
+        // Simulate: workspace router adds a repo and saves to disk
+        const updated = loadConfig(configPath);
+        updated.repos = [...(updated.repos ?? []), '/new/workspace'];
+        saveConfig(configPath, updated);
+        // Simulate: session handler reads config (fresh)
+        const fresh = loadConfig(configPath);
+        assert.ok(fresh.repos.includes('/new/workspace'), 'Fresh loadConfig should see repo added after initial load');
+        assert.ok(fresh.repos.includes('/existing/workspace'), 'Fresh loadConfig should still see original repo');
+    });
+    it('loadConfig sees repos removed from disk after initial load', () => {
+        const initial = loadConfig(configPath);
+        assert.deepEqual(initial.repos, ['/existing/workspace']);
+        // Simulate: workspace router removes the repo
+        const updated = loadConfig(configPath);
+        updated.repos = [];
+        saveConfig(configPath, updated);
+        // Fresh read should see empty list
+        const fresh = loadConfig(configPath);
+        assert.deepEqual(fresh.repos, []);
+    });
+    it('loadConfig sees workspace settings changes', () => {
+        // Add repo settings to disk
+        const config = loadConfig(configPath);
+        config.repoSettings = { '/existing/workspace': { defaultAgent: 'codex' } };
+        saveConfig(configPath, config);
+        // Fresh read should see settings
+        const fresh = loadConfig(configPath);
+        assert.equal(fresh.repoSettings?.['/existing/workspace']?.defaultAgent, 'codex');
+    });
+    it('loadConfig throws when config file is missing', () => {
+        fs.unlinkSync(configPath);
+        assert.throws(() => loadConfig(configPath), {
+            message: /Config file not found/,
+        });
+    });
+    it('loadConfig throws on corrupted JSON', () => {
+        fs.writeFileSync(configPath, '{bad json');
+        assert.throws(() => loadConfig(configPath));
+    });
+});