Codeman/packages/xterm-zerolag-input/test/prompt-finder.test.ts

import { describe, it, expect } from 'vitest';
import { createMockTerminal } from './helpers.js';
import { findPrompt, readTextAfterPrompt } from '../src/prompt-finder.js';
import type { XtermTerminal, PromptFinder } from '../src/types.js';

function term(lines: string[]) {
    return createMockTerminal({ buffer: { lines } });
}

describe('findPrompt', () => {
    describe('character strategy', () => {
        it('finds $ prompt at column 0', () => {
            const { terminal, cleanup } = term(['output line', '$ ls -la']);
            const finder: PromptFinder = { type: 'character', char: '$' };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toEqual({ row: 1, col: 0 });
            cleanup();
        });

        it('finds > prompt', () => {
            const { terminal, cleanup } = term(['> hello']);
            const finder: PromptFinder = { type: 'character', char: '>' };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toEqual({ row: 0, col: 0 });
            cleanup();
        });

        it('finds prompt with prefix (user@host)', () => {
            const { terminal, cleanup } = term(['user@host:~$ command']);
            const finder: PromptFinder = { type: 'character', char: '$' };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toEqual({ row: 0, col: 11 });
            cleanup();
        });

        it('scans bottom-up and returns lowest match', () => {
            const { terminal, cleanup } = term([
                '$ old prompt',
                'output',
                '$ current prompt',
            ]);
            const finder: PromptFinder = { type: 'character', char: '$' };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toEqual({ row: 2, col: 0 });
            cleanup();
        });

        it('returns null when no prompt found', () => {
            const { terminal, cleanup } = term(['no prompt here', 'or here']);
            const finder: PromptFinder = { type: 'character', char: '$' };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toBeNull();
            cleanup();
        });

        it('finds Unicode prompt character', () => {
            const { terminal, cleanup } = term(['\u276f hello']);
            const finder: PromptFinder = { type: 'character', char: '\u276f' };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toEqual({ row: 0, col: 0 });
            cleanup();
        });
    });

    describe('regex strategy', () => {
        it('finds regex prompt', () => {
            const { terminal, cleanup } = term(['user@host:~/dir$ ls']);
            const finder: PromptFinder = { type: 'regex', pattern: /\$/ };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).not.toBeNull();
            expect(pos!.col).toBe(15);
            cleanup();
        });

        it('matches complex PS1 patterns', () => {
            const { terminal, cleanup } = term(['(venv) user % cmd']);
            const finder: PromptFinder = { type: 'regex', pattern: /%/ };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).not.toBeNull();
            expect(pos!.col).toBe(12);
            cleanup();
        });

        it('returns null on no match', () => {
            const { terminal, cleanup } = term(['just output']);
            const finder: PromptFinder = { type: 'regex', pattern: /\$\s*$/ };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toBeNull();
            cleanup();
        });

        it('handles global flag safely (strips g to avoid lastIndex)', () => {
            const { terminal, cleanup } = term(['user@host:~$ cmd']);
            const finder: PromptFinder = { type: 'regex', pattern: /\$/g };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).not.toBeNull();
            expect(pos!.col).toBe(11);
            // Call again — should return same result (no lastIndex drift)
            const pos2 = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos2).toEqual(pos);
            cleanup();
        });
    });

    describe('custom strategy', () => {
        it('uses custom finder function', () => {
            const { terminal, cleanup } = term(['anything']);
            const finder: PromptFinder = {
                type: 'custom',
                find: () => ({ row: 5, col: 10 }),
            };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toEqual({ row: 5, col: 10 });
            cleanup();
        });

        it('handles null from custom finder', () => {
            const { terminal, cleanup } = term(['anything']);
            const finder: PromptFinder = {
                type: 'custom',
                find: () => null,
            };
            const pos = findPrompt(terminal as unknown as XtermTerminal, finder);
            expect(pos).toBeNull();
            cleanup();
        });
    });
});

describe('readTextAfterPrompt', () => {
    it('reads text after prompt with offset', () => {
        const { terminal, cleanup } = term(['$ hello world']);
        const prompt = { row: 0, col: 0 };
        const text = readTextAfterPrompt(terminal as unknown as XtermTerminal, prompt, 2);
        expect(text).toBe('hello world');
        cleanup();
    });

    it('returns empty string for empty prompt line', () => {
        const { terminal, cleanup } = term(['$ ']);
        const prompt = { row: 0, col: 0 };
        const text = readTextAfterPrompt(terminal as unknown as XtermTerminal, prompt, 2);
        expect(text).toBe('');
        cleanup();
    });

    it('trims trailing whitespace', () => {
        const { terminal, cleanup } = term(['$ hello   ']);
        const prompt = { row: 0, col: 0 };
        const text = readTextAfterPrompt(terminal as unknown as XtermTerminal, prompt, 2);
        expect(text).toBe('hello');
        cleanup();
    });

    it('handles offset for complex prompts', () => {
        const { terminal, cleanup } = term(['user@host:~$ ls -la']);
        const prompt = { row: 0, col: 11 };
        const text = readTextAfterPrompt(terminal as unknown as XtermTerminal, prompt, 2);
        expect(text).toBe('ls -la');
        cleanup();
    });
});