Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
import type { WorktreeSelectorModel } from '@inkeep/open-knowledge-core';
import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import { createContext, type ReactNode, use, useState } from 'react';
import { beforeEach, describe, expect, test, vi } from 'vitest';
import type { RecentProjectEntry } from '@/lib/desktop-bridge-types';
type ItemProps = {
children?: ReactNode;
disabled?: boolean;
onSelect?: (e?: unknown) => void;
[key: string]: unknown;
};
const SubStateContext = createContext<{ open: boolean; onOpenChange: (o: boolean) => void }>({
open: false,
onOpenChange: () => {},
});
vi.doMock('@/components/ui/dropdown-menu', () => ({
DropdownMenuItem: ({ children, onSelect, ...props }: ItemProps) => (
<div
role="menuitem"
tabIndex={-1}
onClick={(e) => onSelect?.(e as unknown as Event)}
onKeyDown={() => {}}
{...props}
>
{children}
</div>
),
DropdownMenuLabel: ({ children, ...props }: ItemProps) => <div {...props}>{children}</div>,
DropdownMenuPortal: ({ children }: { children?: ReactNode }) => (
<div data-slot="dropdown-menu-portal">{children}</div>
),
DropdownMenuSub: ({
children,
open,
onOpenChange,
}: {
children?: ReactNode;
open?: boolean;
onOpenChange?: (o: boolean) => void;
}) => (
<SubStateContext value={{ open: !!open, onOpenChange: onOpenChange ?? (() => {}) }}>
{children}
</SubStateContext>
),
DropdownMenuSubTrigger: ({
children,
onClick,
onKeyDown,
...props
}: ItemProps & {
onClick?: (e: React.MouseEvent) => void;
onKeyDown?: (e: React.KeyboardEvent) => void;
}) => {
const { onOpenChange } = use(SubStateContext);
return (
<div
role="menuitem"
tabIndex={-1}
onMouseEnter={() => onOpenChange(true)}
onMouseLeave={() => onOpenChange(false)}
onClick={(e) => {
onClick?.(e);
if (!e.defaultPrevented) onOpenChange(true);
}}
onKeyDown={(e) => {
onKeyDown?.(e);
if (e.defaultPrevented) return;
if (e.key === 'ArrowRight' || e.key === 'Enter' || e.key === ' ') onOpenChange(true);
else if (e.key === 'ArrowLeft' || e.key === 'Escape') onOpenChange(false);
}}
{...props}
>
{children}
</div>
);
},
DropdownMenuSubContent: ({
children,
sideOffset: _sideOffset,
avoidCollisions: _avoidCollisions,
...props
}: ItemProps & { sideOffset?: number; avoidCollisions?: boolean }) => {
const { open, onOpenChange } = use(SubStateContext);
if (!open) return null;
return (
<div role="menu" onMouseLeave={() => onOpenChange(false)} {...props}>
{children}
</div>
);
},
}));
vi.doMock('@/components/ui/input-group', () => ({
InputGroup: ({ children, ...props }: ItemProps) => <div {...props}>{children}</div>,
InputGroupAddon: ({ children }: { children?: ReactNode }) => <span>{children}</span>,
InputGroupInput: (props: React.InputHTMLAttributes<HTMLInputElement>) => <input {...props} />,
}));
const refreshWorktrees = vi.fn(() => {});
vi.doMock('@/lib/worktree-store', () => ({ refreshWorktrees }));
const toastError = vi.fn((_msg: string) => {});
vi.doMock('sonner', () => ({ toast: { error: toastError, success: vi.fn(() => {}) } }));
function main(path: string, commonDir: string, branch = 'main'): RecentProjectEntry {
return {
path,
name: path.split('/').pop() ?? path,
lastOpenedAt: '2026-07-01',
gitCommonDir: commonDir,
mainRoot: path,
checkoutRoot: path,
projectSubPath: '',
isLinkedWorktree: false,
branch,
};
}
function worktree(
path: string,
commonDir: string,
mainRoot: string,
branch: string,
lastOpenedAt = '2026-07-01',
): RecentProjectEntry {
return {
path,
name: path.split('/').pop() ?? path,
lastOpenedAt,
gitCommonDir: commonDir,
mainRoot,
checkoutRoot: path,
projectSubPath: '',
isLinkedWorktree: true,
branch,
};
}
function nonGit(path: string): RecentProjectEntry {
return { path, name: path.split('/').pop() ?? path, lastOpenedAt: '2026-07-01' };
}
function model(
entries: WorktreeSelectorModel['entries'],
mainRoot = '/repo',
): WorktreeSelectorModel {
return { mainRoot, currentBranch: 'main', entries, remoteBranches: [] };
}
function createBridge() {
return {
project: { open: vi.fn(() => Promise.resolve()) },
worktree: {
inventory: vi.fn(() => Promise.resolve({ ok: false as const, reason: 'no-git' as const })),
openInventory: vi.fn(() => Promise.resolve({ ok: true as const })),
create: vi.fn(() =>
Promise.resolve({
ok: true as const,
path: '/repo/.ok/worktrees/feature-x',
created: true,
}),
),
},
};
}
const noGuard = () => false;
function Host({
bridge,
recents,
currentPath,
query,
worktreeModel,
closeMenu,
openNewWorktreeWith,
}: {
bridge: ReturnType<typeof createBridge>;
recents: RecentProjectEntry[];
currentPath: string;
query: string;
worktreeModel: WorktreeSelectorModel | null;
closeMenu: () => void;
openNewWorktreeWith: (name: string) => void;
}) {
const [flyoutPath, setFlyoutPath] = useState<string | null>(null);
return (
<RecentProjectsMenu
bridge={bridge as never}
recents={recents}
currentPath={currentPath}
query={query}
worktreeModel={worktreeModel}
closeMenu={closeMenu}
guardStaleSelect={noGuard}
flyoutPath={flyoutPath}
setFlyoutPath={setFlyoutPath}
openNewWorktreeWith={openNewWorktreeWith}
/>
);
}
function renderMenu(
overrides: Partial<{
bridge: ReturnType<typeof createBridge>;
recents: RecentProjectEntry[];
currentPath: string;
query: string;
worktreeModel: WorktreeSelectorModel | null;
closeMenu: () => void;
openNewWorktreeWith: (name: string) => void;
}> = {},
) {
const bridge = overrides.bridge ?? createBridge();
const closeMenu = overrides.closeMenu ?? vi.fn(() => {});
const openNewWorktreeWith = overrides.openNewWorktreeWith ?? vi.fn((_name: string) => {});
const rendered = render(
<Host
bridge={bridge}
recents={overrides.recents ?? []}
currentPath={overrides.currentPath ?? '/other'}
query={overrides.query ?? ''}
worktreeModel={overrides.worktreeModel ?? null}
closeMenu={closeMenu}
openNewWorktreeWith={openNewWorktreeWith}
/>,
);
return { bridge, closeMenu, openNewWorktreeWith, ...rendered };
}
const { RecentProjectsMenu } = await import('./RecentProjectsMenu');
describe('RecentProjectsMenu — grouped browse (no query)', () => {
beforeEach(cleanup);
test('project rows carry NO folder icon (switcher stays focused on names)', () => {
renderMenu({ recents: [nonGit('/notes')] });
const row = screen.getByTestId('project-switcher-recent-/notes');
expect(row.querySelector('svg')).toBeNull();
});
test('clicking the row body (not the name) opens the worktree flyout, not the project', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
const groupRow = screen.getByTestId('project-switcher-group-/repo');
expect(groupRow.textContent).toContain('/repo');
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
expect(screen.queryByTestId('project-switcher-toggle-/repo')).toBeNull();
fireEvent.click(groupRow);
await waitFor(() => {
expect(screen.getByTestId('project-switcher-flyout-/repo')).not.toBeNull();
});
expect(bridge.project.open).not.toHaveBeenCalled();
});
test('clicking the project name opens the project (root) directly, not the flyout', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
const groupRow = screen.getByTestId('project-switcher-group-/repo');
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
const nameTarget = groupRow.querySelector('[data-project-open]');
expect(nameTarget?.textContent).toBe('repo');
fireEvent.click(nameTarget as Element);
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo',
target: 'new-window',
entryPoint: 'recents',
});
});
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
});
test('hovering the submenu row opens the flyout (hover-open, not click-only) without opening the project', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await waitFor(() => {
expect(screen.getByTestId('project-switcher-flyout-/repo')).not.toBeNull();
});
expect(bridge.project.open).not.toHaveBeenCalled();
});
test('the open flyout content is rendered through DropdownMenuPortal (escapes the menu overflow clip)', async () => {
renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const flyout = await screen.findByTestId('project-switcher-flyout-/repo');
expect(flyout.closest('[data-slot="dropdown-menu-portal"]')).not.toBeNull();
});
test('the flyout closes when the pointer leaves both the row and the flyout (close-on-hover-out)', async () => {
renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const flyout = await screen.findByTestId('project-switcher-flyout-/repo');
fireEvent.mouseLeave(flyout);
await waitFor(() => {
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
});
});
test('keyboard: ArrowRight on the group row opens its flyout; ArrowLeft and Escape close it (a11y C7)', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
const row = screen.getByTestId('project-switcher-group-/repo');
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
fireEvent.keyDown(row, { key: 'ArrowRight' });
await waitFor(() => {
expect(screen.getByTestId('project-switcher-flyout-/repo')).not.toBeNull();
});
expect(bridge.project.open).not.toHaveBeenCalled();
await waitFor(() => {
expect(document.activeElement).toBe(
screen.getByTestId('project-switcher-flyout-search-/repo'),
);
});
fireEvent.keyDown(row, { key: 'ArrowLeft' });
await waitFor(() => {
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
});
fireEvent.keyDown(row, { key: 'ArrowRight' });
await waitFor(() => {
expect(screen.getByTestId('project-switcher-flyout-/repo')).not.toBeNull();
});
fireEvent.keyDown(row, { key: 'Escape' });
await waitFor(() => {
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
});
});
test('keyboard: Enter (and Space) on the group row opens the PROJECT, not the flyout (two-target)', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
const row = screen.getByTestId('project-switcher-group-/repo');
fireEvent.keyDown(row, { key: 'Enter' });
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo',
target: 'new-window',
entryPoint: 'recents',
});
});
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
fireEvent.keyDown(row, { key: ' ' });
await waitFor(() => expect(bridge.project.open).toHaveBeenCalledTimes(2));
expect(screen.queryByTestId('project-switcher-flyout-/repo')).toBeNull();
});
test('the original clone is pinned first and badged `primary`, other opened worktrees are badged `worktree`; clicking one opens its window', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const mainEntry = await screen.findByTestId('project-switcher-flyout-entry-/repo');
expect(mainEntry.textContent).toContain('main');
expect(mainEntry.textContent).toContain('primary');
const devEntry = screen.getByTestId('project-switcher-flyout-entry-/repo/.ok/worktrees/dev');
expect(devEntry.textContent).toContain('dev');
expect(devEntry.textContent).toContain('worktree');
expect(mainEntry.querySelector('svg')).toBeNull();
expect(devEntry.querySelector('svg')).toBeNull();
const flyoutSearch = screen.getByTestId('project-switcher-flyout-search-/repo');
expect(flyoutSearch.parentElement?.querySelectorAll('svg').length).toBe(1);
fireEvent.click(devEntry);
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo/.ok/worktrees/dev',
target: 'new-window',
entryPoint: 'worktree',
requireExactManagedProject: true,
});
});
});
test('the badge on the original clone survives having a feature branch checked out there (PRD-7330)', async () => {
renderMenu({
recents: [
main('/repo', '/repo/.git', 'theming-as-plugin'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
worktreeModel: model([
{
branch: 'theming-as-plugin',
worktreePath: '/repo',
isCurrent: true,
isMain: true,
locked: false,
},
{ branch: 'main', worktreePath: null, isCurrent: false, isMain: false, locked: false },
]),
currentPath: '/repo',
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const rootEntry = await screen.findByTestId('project-switcher-flyout-entry-/repo');
expect(rootEntry.textContent).toContain('theming-as-plugin');
expect(rootEntry.textContent).toContain('primary');
expect(rootEntry.textContent).not.toContain('default');
const mainBranchRow = screen.getByTestId('project-switcher-flyout-entry-branch:main');
expect(mainBranchRow.textContent).not.toContain('primary');
expect(mainBranchRow.textContent).toContain('create worktree');
});
test('opened worktrees sort by recency (most-recently-opened first)', async () => {
renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/older', '/repo/.git', '/repo', 'older', '2026-06-01'),
worktree('/repo/.ok/worktrees/newer', '/repo/.git', '/repo', 'newer', '2026-06-30'),
],
});
expect(screen.queryByTestId('project-switcher-toggle-/repo')).toBeNull();
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const flyout = await screen.findByTestId('project-switcher-flyout-/repo');
const ids = [...flyout.querySelectorAll('[data-testid^="project-switcher-flyout-entry-"]')].map(
(el) => el.getAttribute('data-testid'),
);
expect(ids).toEqual([
'project-switcher-flyout-entry-/repo',
'project-switcher-flyout-entry-/repo/.ok/worktrees/newer',
'project-switcher-flyout-entry-/repo/.ok/worktrees/older',
]);
});
test('lazy inventory adds a registered checkout that was never in Recents', async () => {
const bridge = createBridge();
bridge.worktree.inventory.mockResolvedValue({
ok: true,
inventory: {
gitCommonDir: '/repo/.git',
primaryCheckoutRoot: '/repo',
projectSubPath: '',
entries: [
{
checkoutRoot: '/repo',
projectPath: '/repo',
branch: 'main',
headSha: '1',
location: 'primary',
availability: 'available',
locked: false,
prunable: false,
},
{
checkoutRoot: '/repo/.ok/worktrees/ghost',
projectPath: '/repo/.ok/worktrees/ghost',
branch: 'ghost',
headSha: '2',
location: 'internal',
availability: 'available',
locked: false,
prunable: false,
},
],
},
});
renderMenu({
bridge,
recents: [main('/repo', '/repo/.git')],
currentPath: '/repo',
worktreeModel: model([
{ branch: 'main', worktreePath: '/repo', isCurrent: true, isMain: true, locked: false },
{
branch: 'ghost',
worktreePath: '/repo/.ok/worktrees/ghost',
isCurrent: false,
isMain: false,
locked: false,
},
]),
});
expect(screen.getByTestId('project-switcher-group-/repo')).not.toBeNull();
expect(screen.queryByTestId('project-switcher-toggle-/repo')).toBeNull();
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await screen.findByTestId('project-switcher-flyout-/repo');
await waitFor(() => {
expect(screen.getByTestId('project-switcher-toggle-/repo').textContent).toContain(
'1 worktree',
);
});
expect(
screen.getByTestId('project-switcher-flyout-entry-/repo/.ok/worktrees/ghost'),
).not.toBeNull();
fireEvent.mouseLeave(screen.getByTestId('project-switcher-flyout-/repo'));
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await waitFor(() => expect(bridge.worktree.inventory).toHaveBeenCalledTimes(2));
});
test('a zero-worktree repository exposes loading and initial-error states on first open', async () => {
const bridge = createBridge();
let resolveInventory:
| ((result: { ok: false; reason: 'enumeration-failed' }) => void)
| undefined;
bridge.worktree.inventory.mockImplementation(() => {
const { promise, resolve } = Promise.withResolvers<{
ok: false;
reason: 'enumeration-failed';
}>();
resolveInventory = resolve;
return promise;
});
renderMenu({ bridge, recents: [main('/repo', '/repo/.git')] });
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
expect(await screen.findByText('Loading worktrees…')).not.toBeNull();
resolveInventory?.({ ok: false, reason: 'enumeration-failed' });
expect(await screen.findByText("Couldn't load worktrees.")).not.toBeNull();
});
test('the flyout search filters that project’s worktrees + branches; a create-on-demand branch creates its worktree', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
currentPath: '/repo',
worktreeModel: model([
{ branch: 'main', worktreePath: '/repo', isCurrent: true, isMain: true, locked: false },
{
branch: 'dev',
worktreePath: '/repo/.ok/worktrees/dev',
isCurrent: false,
isMain: false,
locked: false,
},
{ branch: 'feature-x', worktreePath: null, isCurrent: false, isMain: false, locked: false },
]),
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await screen.findByTestId('project-switcher-flyout-/repo');
const createRow = screen.getByTestId('project-switcher-flyout-entry-branch:feature-x');
expect(createRow.textContent).toContain('feature-x');
expect(createRow.textContent).toContain('create worktree');
const searchBox = screen.getByTestId(
'project-switcher-flyout-search-/repo',
) as HTMLInputElement;
expect(searchBox.placeholder).toBe('Search worktrees');
fireEvent.change(searchBox, { target: { value: 'feature' } });
await waitFor(() => {
expect(
screen.queryByTestId('project-switcher-flyout-entry-/repo/.ok/worktrees/dev'),
).toBeNull();
});
expect(screen.getByTestId('project-switcher-flyout-entry-branch:feature-x')).not.toBeNull();
fireEvent.click(screen.getByTestId('project-switcher-flyout-entry-branch:feature-x'));
await waitFor(() => {
expect(bridge.worktree.create).toHaveBeenCalledWith({
branch: 'feature-x',
createBranch: false,
});
});
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo/.ok/worktrees/feature-x',
target: 'new-window',
entryPoint: 'worktree',
requireExactManagedProject: true,
});
});
expect(refreshWorktrees).toHaveBeenCalled();
});
test('the current project flyout offers "Create worktree <query>" when nothing matches; clicking it opens the pre-filled dialog', async () => {
const openNewWorktreeWith = vi.fn((_name: string) => {});
renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
currentPath: '/repo',
worktreeModel: model([
{ branch: 'main', worktreePath: '/repo', isCurrent: true, isMain: true, locked: false },
{
branch: 'dev',
worktreePath: '/repo/.ok/worktrees/dev',
isCurrent: false,
isMain: false,
locked: false,
},
]),
openNewWorktreeWith,
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await screen.findByTestId('project-switcher-flyout-/repo');
const searchBox = screen.getByTestId(
'project-switcher-flyout-search-/repo',
) as HTMLInputElement;
fireEvent.change(searchBox, { target: { value: ' new-thing ' } });
await waitFor(() => {
expect(screen.getByText('No matching worktrees or branches.')).not.toBeNull();
});
const createOption = screen.getByTestId('project-switcher-flyout-create');
expect(createOption.textContent).toContain('Create worktree');
expect(createOption.textContent).toContain('new-thing');
fireEvent.click(createOption);
expect(openNewWorktreeWith).toHaveBeenCalledWith('new-thing');
});
test('the create option is absent when the query is only whitespace (nothing to name)', async () => {
renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
currentPath: '/repo',
worktreeModel: model([
{ branch: 'main', worktreePath: '/repo', isCurrent: true, isMain: true, locked: false },
{
branch: 'dev',
worktreePath: '/repo/.ok/worktrees/dev',
isCurrent: false,
isMain: false,
locked: false,
},
]),
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await screen.findByTestId('project-switcher-flyout-/repo');
const searchBox = screen.getByTestId(
'project-switcher-flyout-search-/repo',
) as HTMLInputElement;
fireEvent.change(searchBox, { target: { value: ' ' } });
expect(screen.queryByTestId('project-switcher-flyout-create')).toBeNull();
});
test('a NON-current project flyout does NOT offer the create option (creation anchors to the current project)', async () => {
renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
currentPath: '/elsewhere',
worktreeModel: model(
[
{
branch: 'other-branch',
worktreePath: null,
isCurrent: false,
isMain: false,
locked: false,
},
],
'/elsewhere',
),
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await screen.findByTestId('project-switcher-flyout-/repo');
const searchBox = screen.getByTestId(
'project-switcher-flyout-search-/repo',
) as HTMLInputElement;
fireEvent.change(searchBox, { target: { value: 'zzz-no-match' } });
await waitFor(() => {
expect(screen.getByText('No matching worktrees or branches.')).not.toBeNull();
});
expect(screen.queryByTestId('project-switcher-flyout-create')).toBeNull();
});
test('a non-current project flyout shows only its opened worktrees (no branch model)', async () => {
renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
currentPath: '/elsewhere',
worktreeModel: model(
[
{
branch: 'other-branch',
worktreePath: null,
isCurrent: false,
isMain: false,
locked: false,
},
],
'/elsewhere',
),
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const flyout = await screen.findByTestId('project-switcher-flyout-/repo');
expect(flyout.textContent).not.toContain('other-branch');
expect(screen.getByTestId('project-switcher-flyout-entry-/repo')).not.toBeNull();
expect(
screen.getByTestId('project-switcher-flyout-entry-/repo/.ok/worktrees/dev'),
).not.toBeNull();
});
test('the flyout’s pinned original-clone entry also opens the project root (secondary path to the same action)', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const mainEntry = await screen.findByTestId('project-switcher-flyout-entry-/repo');
expect(bridge.project.open).not.toHaveBeenCalled();
fireEvent.click(mainEntry);
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo',
target: 'new-window',
entryPoint: 'recents',
});
});
});
test('a non-git recent is a flat row that opens with the recents entry point', async () => {
const { bridge } = renderMenu({ recents: [nonGit('/notes')] });
expect(screen.queryByTestId('project-switcher-group-/notes')).toBeNull();
fireEvent.click(screen.getByTestId('project-switcher-recent-/notes'));
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/notes',
target: 'new-window',
entryPoint: 'recents',
});
});
});
test('the current project row no-ops on select and just closes the menu', async () => {
const { bridge, closeMenu } = renderMenu({
recents: [nonGit('/notes')],
currentPath: '/notes',
});
fireEvent.click(screen.getByTestId('project-switcher-recent-/notes'));
expect(bridge.project.open).not.toHaveBeenCalled();
expect(closeMenu).toHaveBeenCalled();
});
test('a repo present only via a worktree synthesizes the project row', async () => {
renderMenu({
recents: [worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev')],
});
const groupRow = screen.getByTestId('project-switcher-group-/repo/.ok/worktrees/dev');
expect(groupRow.textContent).toContain('/repo/.ok/worktrees/dev');
fireEvent.mouseEnter(groupRow);
await screen.findByTestId('project-switcher-flyout-/repo/.ok/worktrees/dev');
const devEntry = screen.getByTestId('project-switcher-flyout-entry-/repo/.ok/worktrees/dev');
expect(devEntry).not.toBeNull();
expect(screen.queryByTestId('project-switcher-flyout-entry-/repo')).toBeNull();
expect(devEntry.textContent).toContain('worktree');
expect(devEntry.textContent).not.toContain('primary');
});
test('another repository loads lazily, searches never-opened external paths, and opens exact inventory identity', async () => {
const bridge = createBridge();
bridge.worktree.inventory.mockImplementation(async ({ projectPath }) => {
if (projectPath !== '/other') return { ok: false as const, reason: 'no-git' as const };
return {
ok: true as const,
inventory: {
gitCommonDir: '/other/.git',
primaryCheckoutRoot: '/other',
projectSubPath: '',
entries: [
{
checkoutRoot: '/other',
projectPath: '/other',
branch: 'main',
headSha: '1',
location: 'primary' as const,
availability: 'available' as const,
locked: false,
prunable: false,
},
{
checkoutRoot: '/outside/other-locked',
projectPath: '/outside/other-locked',
branch: 'locked-feature',
headSha: '2',
location: 'external' as const,
availability: 'available' as const,
locked: true,
prunable: false,
},
{
checkoutRoot: '/outside/other-missing',
projectPath: '/outside/other-missing',
branch: 'missing-feature',
headSha: '3',
location: 'external' as const,
availability: 'missing' as const,
locked: false,
prunable: false,
},
{
checkoutRoot: '/outside/other-prunable',
projectPath: '/outside/other-prunable',
branch: 'prunable-feature',
headSha: '4',
location: 'external' as const,
availability: 'missing' as const,
locked: false,
prunable: true,
},
],
},
};
});
renderMenu({
bridge,
recents: [main('/repo', '/repo/.git'), main('/other', '/other/.git')],
currentPath: '/repo',
});
expect(bridge.worktree.inventory).not.toHaveBeenCalled();
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/other'));
await waitFor(() => {
expect(bridge.worktree.inventory).toHaveBeenCalledWith({ projectPath: '/other' });
});
const search = screen.getByTestId('project-switcher-flyout-search-/other');
fireEvent.change(search, { target: { value: 'other-locked' } });
const locked = await screen.findByTestId('project-switcher-flyout-entry-/outside/other-locked');
expect(locked.textContent).toContain('locked');
fireEvent.click(locked);
await waitFor(() => {
expect(bridge.worktree.openInventory).toHaveBeenCalledWith({
anchorProjectPath: '/other',
gitCommonDir: '/other/.git',
projectSubPath: '',
checkoutRoot: '/outside/other-locked',
projectPath: '/outside/other-locked',
});
});
expect(bridge.project.open).not.toHaveBeenCalledWith(
expect.objectContaining({ path: '/outside/other-locked' }),
);
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/other'));
await screen.findByTestId('project-switcher-flyout-/other');
fireEvent.change(screen.getByTestId('project-switcher-flyout-search-/other'), {
target: { value: '' },
});
expect(
screen
.getByTestId('project-switcher-flyout-entry-/outside/other-missing')
.getAttribute('aria-disabled'),
).toBe('true');
expect(
screen
.getByTestId('project-switcher-flyout-entry-/outside/other-prunable')
.getAttribute('aria-disabled'),
).toBe('true');
fireEvent.keyDown(screen.getByTestId('project-switcher-flyout-entry-/outside/other-missing'), {
key: 'Enter',
});
expect(bridge.worktree.openInventory).toHaveBeenCalledTimes(1);
});
test('global search retains inventory-only checkouts from every repository already loaded', async () => {
const bridge = createBridge();
bridge.worktree.inventory.mockImplementation(async ({ projectPath }) => ({
ok: true as const,
inventory: {
gitCommonDir: `${projectPath}/.git`,
primaryCheckoutRoot: projectPath,
projectSubPath: '',
entries: [
{
checkoutRoot: projectPath,
projectPath,
branch: 'main',
headSha: '1',
location: 'primary' as const,
availability: 'available' as const,
locked: false,
prunable: false,
},
{
checkoutRoot: `/outside${projectPath}-only`,
projectPath: `/outside${projectPath}-only`,
branch: `${projectPath.slice(1)}-only`,
headSha: '2',
location: 'external' as const,
availability: 'available' as const,
locked: false,
prunable: false,
},
],
},
}));
const recents = [main('/repo', '/repo/.git'), main('/other', '/other/.git')];
const rendered = renderMenu({ bridge, recents, currentPath: '/repo' });
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
await waitFor(() =>
expect(bridge.worktree.inventory).toHaveBeenCalledWith({ projectPath: '/repo' }),
);
fireEvent.mouseLeave(await screen.findByTestId('project-switcher-flyout-/repo'));
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/other'));
await waitFor(() =>
expect(bridge.worktree.inventory).toHaveBeenCalledWith({ projectPath: '/other' }),
);
rendered.rerender(
<Host
bridge={bridge}
recents={recents}
currentPath="/repo"
query="repo-only"
worktreeModel={null}
closeMenu={rendered.closeMenu}
openNewWorktreeWith={rendered.openNewWorktreeWith}
/>,
);
expect(screen.getByTestId('project-switcher-inventory-/outside/repo-only')).not.toBeNull();
});
test('Enter never opens a disabled recent-only worktree row', async () => {
const missing = {
...worktree('/repo/.ok/worktrees/missing', '/repo/.git', '/repo', 'missing'),
missing: true,
};
const { bridge } = renderMenu({
recents: [main('/repo', '/repo/.git'), missing],
currentPath: '/repo',
});
fireEvent.mouseEnter(screen.getByTestId('project-switcher-group-/repo'));
const row = await screen.findByTestId(
'project-switcher-flyout-entry-/repo/.ok/worktrees/missing',
);
expect(row.getAttribute('aria-disabled')).toBe('true');
expect(row.textContent).toContain('project missing');
const search = screen.getByTestId('project-switcher-flyout-search-/repo');
fireEvent.keyDown(search, { key: 'ArrowDown' });
const primary = screen.getByTestId('project-switcher-flyout-entry-/repo');
fireEvent.keyDown(primary, { key: 'ArrowDown' });
expect(document.activeElement).toBe(row);
fireEvent.keyDown(row, { key: 'Enter' });
expect(bridge.worktree.openInventory).not.toHaveBeenCalled();
expect(bridge.project.open).not.toHaveBeenCalled();
});
});
describe('RecentProjectsMenu — flyout keyboard navigation (item 29)', () => {
beforeEach(cleanup);
function openThreeRowFlyout() {
const utils = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/older', '/repo/.git', '/repo', 'older', '2026-06-01'),
worktree('/repo/.ok/worktrees/newer', '/repo/.git', '/repo', 'newer', '2026-06-30'),
],
});
fireEvent.keyDown(screen.getByTestId('project-switcher-group-/repo'), { key: 'ArrowRight' });
return utils;
}
const row = (key: string) => screen.getByTestId(`project-switcher-flyout-entry-${key}`);
test('ArrowDown from the search input moves focus to the first entry row', async () => {
openThreeRowFlyout();
const search = await screen.findByTestId('project-switcher-flyout-search-/repo');
await waitFor(() => expect(document.activeElement).toBe(search));
fireEvent.keyDown(search, { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo'));
});
test('ArrowDown / ArrowUp rove through the entry rows and clamp at the ends', async () => {
openThreeRowFlyout();
const search = await screen.findByTestId('project-switcher-flyout-search-/repo');
await waitFor(() => expect(document.activeElement).toBe(search));
fireEvent.keyDown(search, { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo'));
fireEvent.keyDown(row('/repo'), { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo/.ok/worktrees/newer'));
fireEvent.keyDown(row('/repo/.ok/worktrees/newer'), { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo/.ok/worktrees/older'));
fireEvent.keyDown(row('/repo/.ok/worktrees/older'), { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo/.ok/worktrees/older'));
fireEvent.keyDown(row('/repo/.ok/worktrees/older'), { key: 'ArrowUp' });
expect(document.activeElement).toBe(row('/repo/.ok/worktrees/newer'));
fireEvent.keyDown(row('/repo/.ok/worktrees/newer'), { key: 'ArrowUp' });
expect(document.activeElement).toBe(row('/repo'));
});
test('ArrowUp from the first entry row returns focus to the search input', async () => {
openThreeRowFlyout();
const search = await screen.findByTestId('project-switcher-flyout-search-/repo');
await waitFor(() => expect(document.activeElement).toBe(search));
fireEvent.keyDown(search, { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo'));
fireEvent.keyDown(row('/repo'), { key: 'ArrowUp' });
expect(document.activeElement).toBe(search);
});
test('Enter on a focused entry row opens that worktree (same action as a click)', async () => {
const { bridge } = openThreeRowFlyout();
const search = await screen.findByTestId('project-switcher-flyout-search-/repo');
await waitFor(() => expect(document.activeElement).toBe(search));
fireEvent.keyDown(search, { key: 'ArrowDown' });
fireEvent.keyDown(row('/repo'), { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo/.ok/worktrees/newer'));
fireEvent.keyDown(row('/repo/.ok/worktrees/newer'), { key: 'Enter' });
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo/.ok/worktrees/newer',
target: 'new-window',
entryPoint: 'worktree',
requireExactManagedProject: true,
});
});
});
test('typing in the search still filters the list, and ArrowDown enters the filtered rows', async () => {
openThreeRowFlyout();
const search = (await screen.findByTestId(
'project-switcher-flyout-search-/repo',
)) as HTMLInputElement;
await waitFor(() => expect(document.activeElement).toBe(search));
fireEvent.change(search, { target: { value: 'newer' } });
await waitFor(() => {
expect(
screen.queryByTestId('project-switcher-flyout-entry-/repo/.ok/worktrees/older'),
).toBeNull();
});
fireEvent.keyDown(search, { key: 'ArrowDown' });
expect(document.activeElement).toBe(row('/repo/.ok/worktrees/newer'));
});
});
describe('RecentProjectsMenu — search (cross-project)', () => {
beforeEach(cleanup);
test('project search rows carry NO folder icon', () => {
renderMenu({ recents: [main('/repo', '/repo/.git')], query: 'repo' });
const row = screen.getByTestId('project-switcher-recent-/repo');
expect(row.querySelector('svg')).toBeNull();
});
test('matches an opened worktree by branch name and opens it as a worktree', async () => {
const { bridge } = renderMenu({
recents: [
main('/repo', '/repo/.git'),
worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev'),
],
query: 'dev',
});
const row = screen.getByTestId('project-switcher-worktree-/repo/.ok/worktrees/dev');
expect(row.textContent).toContain('dev');
expect(row.textContent).toContain('repo');
fireEvent.click(row);
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo/.ok/worktrees/dev',
target: 'new-window',
entryPoint: 'worktree',
requireExactManagedProject: true,
});
});
});
test('matches an un-opened branch from the cached model and creates its worktree on demand', async () => {
const { bridge } = renderMenu({
query: 'feature',
worktreeModel: model([
{ branch: 'feature-x', worktreePath: null, isCurrent: false, isMain: false, locked: false },
]),
});
expect(screen.getByTestId('project-switcher-branch-feature-x').textContent).toContain('repo');
fireEvent.click(screen.getByTestId('project-switcher-branch-feature-x'));
await waitFor(() => {
expect(bridge.worktree.create).toHaveBeenCalledWith({
branch: 'feature-x',
createBranch: false,
});
});
await waitFor(() => {
expect(bridge.project.open).toHaveBeenCalledWith({
path: '/repo/.ok/worktrees/feature-x',
target: 'new-window',
entryPoint: 'worktree',
requireExactManagedProject: true,
});
});
expect(refreshWorktrees).toHaveBeenCalled();
});
test('does not double-list a branch already shown as an opened worktree', () => {
renderMenu({
recents: [worktree('/repo/.ok/worktrees/dev', '/repo/.git', '/repo', 'dev')],
query: 'dev',
worktreeModel: model([
{
branch: 'dev',
worktreePath: '/repo/.ok/worktrees/dev',
isCurrent: false,
isMain: false,
locked: false,
},
]),
});
expect(screen.getByTestId('project-switcher-worktree-/repo/.ok/worktrees/dev')).not.toBeNull();
expect(screen.queryByTestId('project-switcher-branch-dev')).toBeNull();
});
test('announces when nothing matches', () => {
renderMenu({ recents: [main('/repo', '/repo/.git')], query: 'zzz-nothing' });
expect(screen.getByRole('status').textContent).toBe('No matching projects.');
});
test('a failed create-on-demand toasts and does not open a window', async () => {
toastError.mockClear();
const bridge = createBridge();
bridge.worktree.create = vi.fn(() =>
Promise.resolve({ ok: false as const, reason: 'branch-exists' as const }),
);
renderMenu({
bridge,
query: 'feature',
worktreeModel: model([
{ branch: 'feature-x', worktreePath: null, isCurrent: false, isMain: false, locked: false },
]),
});
fireEvent.click(screen.getByTestId('project-switcher-branch-feature-x'));
await waitFor(() => expect(bridge.worktree.create).toHaveBeenCalledTimes(1));
await waitFor(() => expect(toastError).toHaveBeenCalled());
expect(bridge.project.open).not.toHaveBeenCalled();
});
test('a rejected project scope shows its cause, refreshes, and never opens', async () => {
toastError.mockClear();
refreshWorktrees.mockClear();
const bridge = createBridge();
bridge.worktree.create = vi.fn(() =>
Promise.resolve({
ok: false as const,
reason: 'project-scope-unavailable' as const,
issue: 'outside-worktree' as const,
path: '/repo/.ok/worktrees/feature-x',
created: true as const,
}),
);
renderMenu({
bridge,
query: 'feature',
worktreeModel: model([
{ branch: 'feature-x', worktreePath: null, isCurrent: false, isMain: false, locked: false },
]),
});
fireEvent.click(screen.getByTestId('project-switcher-branch-feature-x'));
await waitFor(() =>
expect(toastError).toHaveBeenCalledWith(
'The OpenKnowledge project path on this branch leaves the worktree. The worktree was created but not opened.',
),
);
expect(refreshWorktrees).toHaveBeenCalledTimes(1);
expect(bridge.project.open).not.toHaveBeenCalled();
});
});