Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

10.7 KB
Raw Blame
import type { CreateScenario, InstallState } from '@inkeep/open-knowledge-core';
import { i18n } from '@lingui/core';
import * as actualLinguiMacro from '@lingui/react/macro';
import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import type { JSONContent } from '@tiptap/core';
import { type ReactNode, type Ref, useImperativeHandle, useRef, useState } from 'react';
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { __resetComposerDraftForTests } from './composer-draft-store';
import { createComposerDropdownMenuMock } from './composer-dropdown-menu.test-helper';

vi.doMock('@lingui/react/macro', () => ({
  ...actualLinguiMacro,
  Trans: ({ children }: { children: ReactNode }) => <>{children}</>,
  useLingui: () => ({
    i18n,
    t: (strings: TemplateStringsArray, ...values: unknown[]) =>
      strings.reduce((acc, part, index) => `${acc}${part}${values[index] ?? ''}`, ''),
  }),
}));

vi.doMock('@/lib/config-context', () => ({
  useConfigContext: () => ({ merged: { appearance: { preview: { autoOpen: true } } } }),
}));

vi.doMock('@/components/PageListContext', () => ({
  usePageList: () => ({ pageMeta: new Map() }),
}));

vi.doMock('@/components/handoff/OpenInAgentMenuItem', () => ({
  TargetIcon: ({ id }: { id: string }) => <span data-testid={`target-icon-${id}`} />,
}));

vi.doMock('@/components/ui/dropdown-menu', createComposerDropdownMenuMock);

const installedAll: Record<string, InstallState> = {
  'claude-cowork': { installed: false },
  'claude-code': { installed: true },
  codex: { installed: true },
  cursor: { installed: true },
};
vi.doMock('@/components/handoff/useInstalledAgents', () => ({
  useInstalledAgents: () => ({ states: installedAll, refresh: () => Promise.resolve() }),
}));

vi.doMock('@/lib/use-workspace', () => ({
  useWorkspace: () => ({ contentDir: '/tmp/project', pathSeparator: '/' }),
}));

vi.doMock('@/hooks/use-selection-context', () => ({
  useSelectionContext: () => null,
}));

vi.doMock('@/components/handoff/useHandoffDispatch', () => ({
  useHandoffDispatch: () => ({ dispatch: () => Promise.resolve({ ok: true }) }),
  buildComposerHandoffInput: (args: { instruction: string }) => ({
    compose: { instruction: args.instruction },
  }),
  startAgentThreadForInput: () => {},
  buildCreateHandoffInput: (args: { description: string }) => ({
    createDescription: args.description,
  }),
  getDisplayNameDefault: (id: string) => id,
  openInstallUrl: () => Promise.resolve(),
}));

vi.doMock('sonner', () => ({ toast: { error: () => {}, success: () => {} } }));

type Handle = {
  focus: () => void;
  blur: () => void;
  clear: () => void;
  setText: (text: string) => void;
  getContent: () => { instruction: string; mentions: string[] };
};

function docToInstruction(doc: JSONContent | undefined): string {
  if (!doc?.content) return '';
  return doc.content
    .map((block) =>
      (block.content ?? [])
        .map((node) =>
          node.type === 'composerMention' ? `@${node.attrs?.path ?? ''}` : (node.text ?? ''),
        )
        .join(''),
    )
    .join('\n')
    .trim();
}

function textToDoc(value: string): JSONContent {
  return {
    type: 'doc',
    content: [{ type: 'paragraph', content: value ? [{ type: 'text', text: value }] : [] }],
  };
}

vi.doMock('@/editor/ComposerMentionInput', () => ({
  ComposerMentionInput: ({
    ref,
    ariaLabel,
    onEmptyChange,
    onContentChange,
    onSubmit,
    initialDoc,
  }: {
    ref?: Ref<Handle>;
    ariaLabel: string;
    onEmptyChange: (isEmpty: boolean) => void;
    onContentChange?: (doc: JSONContent) => void;
    onSubmit: () => void;
    initialDoc?: JSONContent;
  }) => {
    const [doc, setDoc] = useState<JSONContent>(() => initialDoc ?? textToDoc(''));
    const localRef = useRef<HTMLTextAreaElement>(null);

    const emit = (next: JSONContent) => {
      setDoc(next);
      onEmptyChange(docToInstruction(next) === '');
      onContentChange?.(next);
    };

    useImperativeHandle(ref, () => ({
      focus: () => localRef.current?.focus(),
      blur: () => localRef.current?.blur(),
      clear: () => emit(textToDoc('')),
      setText: (text: string) => emit(textToDoc(text)),
      getContent: () => {
        const mentions: string[] = [];
        for (const block of doc.content ?? []) {
          for (const node of block.content ?? []) {
            if (node.type === 'composerMention' && node.attrs?.path) {
              mentions.push(String(node.attrs.path));
            }
          }
        }
        return { instruction: docToInstruction(doc), mentions };
      },
    }));

    const mentionNodes = (doc.content ?? []).flatMap((block) =>
      (block.content ?? []).filter((node) => node.type === 'composerMention'),
    );

    return (
      <div>
        <textarea
          ref={localRef}
          aria-label={ariaLabel}
          value={docToInstruction(doc)}
          onChange={(event) => emit(textToDoc(event.target.value))}
          onKeyDown={(event) => {
            if (event.key === 'Enter' && !event.shiftKey) {
              event.preventDefault();
              onSubmit();
            }
          }}
        />
        {mentionNodes.map((node, i) => (
          <span
            // biome-ignore lint/suspicious/noArrayIndexKey: stable list of seeded chips in a test double
            key={i}
            className="composer-mention"
            data-composer-mention={String(node.attrs?.path ?? '')}
          >
            @{String(node.attrs?.label ?? node.attrs?.path ?? '')}
          </span>
        ))}
        <button
          type="button"
          data-testid={`insert-mention-${ariaLabel}`}
          onClick={() => {
            const block = doc.content?.[0] ?? { type: 'paragraph', content: [] };
            const next: JSONContent = {
              type: 'doc',
              content: [
                {
                  ...block,
                  content: [
                    ...(block.content ?? []),
                    { type: 'composerMention', attrs: { path: 'ideas/foo.md', label: 'Foo' } },
                  ],
                },
              ],
            };
            emit(next);
          }}
        >
          insert mention
        </button>
      </div>
    );
  },
}));

const { BottomComposer } = await import('./BottomComposer');
const { CreatePromptComposer } = await import('./empty-state/CreatePromptComposer');
const { registerAgent } = await import('@/lib/acp/registered-agents');
const { TooltipProvider } = await import('@/components/ui/tooltip');

beforeEach(() => {
  try {
    window.localStorage.clear();
  } catch {}
  __resetComposerDraftForTests();
  registerAgent({ source: 'registry', id: 'claude-acp', name: 'Claude' }, { makeDefault: true });
});

afterEach(() => {
  cleanup();
  __resetComposerDraftForTests();
});

function bottomInput() {
  return screen.getByRole('textbox', { name: 'Ask AI' }) as HTMLTextAreaElement;
}

function heroInput() {
  return screen.getByRole('textbox', {
    name: 'Describe the project you want to create',
  }) as HTMLTextAreaElement;
}

describe('shared draft across composer placements', () => {
  test('a draft typed in the bottom (docked) composer appears in the create (hero) composer', async () => {
    const docked = render(<BottomComposer docName="notes" surface="wysiwyg" />, {
      wrapper: TooltipProvider,
    });
    fireEvent.change(bottomInput(), { target: { value: 'condense my AGENTS.md' } });

    docked.unmount();

    render(<CreatePromptComposer scenario={'new-project' as CreateScenario} />, {
      wrapper: TooltipProvider,
    });
    await waitFor(() => expect(heroInput().value).toBe('condense my AGENTS.md'));
  });

  test('a draft typed in the create (hero) composer appears in the bottom (docked) composer', async () => {
    const hero = render(<CreatePromptComposer scenario={'new-project' as CreateScenario} />, {
      wrapper: TooltipProvider,
    });
    fireEvent.change(heroInput(), { target: { value: 'research flightless birds' } });

    hero.unmount();

    render(<BottomComposer docName="notes" surface="wysiwyg" />, { wrapper: TooltipProvider });
    await waitFor(() => expect(bottomInput().value).toBe('research flightless birds'));
  });

  test('an @-mention chip inserted in the bottom composer survives as a chip node in the create composer', async () => {
    const docked = render(<BottomComposer docName="notes" surface="wysiwyg" />, {
      wrapper: TooltipProvider,
    });
    fireEvent.change(bottomInput(), { target: { value: 'see ' } });
    fireEvent.click(screen.getByTestId('insert-mention-Ask AI'));

    docked.unmount();

    render(<CreatePromptComposer scenario={'new-project' as CreateScenario} />, {
      wrapper: TooltipProvider,
    });

    await waitFor(() => {
      const chip = document.querySelector(
        '.composer-mention[data-composer-mention="ideas/foo.md"]',
      );
      expect(chip).not.toBeNull();
    });
  });

  test('the chip also survives the reverse direction (hero → bottom)', async () => {
    const hero = render(<CreatePromptComposer scenario={'new-project' as CreateScenario} />, {
      wrapper: TooltipProvider,
    });
    fireEvent.change(heroInput(), { target: { value: 'reference ' } });
    fireEvent.click(screen.getByTestId('insert-mention-Describe the project you want to create'));

    hero.unmount();

    render(<BottomComposer docName="notes" surface="wysiwyg" />, { wrapper: TooltipProvider });
    await waitFor(() => {
      const chip = document.querySelector(
        '.composer-mention[data-composer-mention="ideas/foo.md"]',
      );
      expect(chip).not.toBeNull();
    });
  });

  test('the draft survives a doc → empty → doc round trip (remount restores it)', async () => {
    const first = render(<BottomComposer docName="notes" surface="wysiwyg" />, {
      wrapper: TooltipProvider,
    });
    fireEvent.change(bottomInput(), { target: { value: 'summarize my week' } });
    first.unmount();

    const empty = render(<CreatePromptComposer scenario={'new-project' as CreateScenario} />, {
      wrapper: TooltipProvider,
    });
    await waitFor(() => expect(heroInput().value).toBe('summarize my week'));
    empty.unmount();

    render(<BottomComposer docName="other" surface="wysiwyg" />, { wrapper: TooltipProvider });
    await waitFor(() => expect(bottomInput().value).toBe('summarize my week'));
  });

  test('the draft persists across a reload (store re-hydrates the doc from storage)', async () => {
    const docked = render(<BottomComposer docName="notes" surface="wysiwyg" />, {
      wrapper: TooltipProvider,
    });
    fireEvent.change(bottomInput(), { target: { value: 'draft a spec' } });
    docked.unmount();

    __resetComposerDraftForTests();

    render(<BottomComposer docName="notes" surface="wysiwyg" />, { wrapper: TooltipProvider });
    await waitFor(() => expect(bottomInput().value).toBe('draft a spec'));
  });
});