Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

20.2 KB
Raw Blame
import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { afterEach, describe, expect, test, vi } from 'vitest';
import { TooltipProvider } from '@/components/ui/tooltip';
import type {
  OkDesktopBridge,
  OkPackId,
  OkScaffoldPlan,
  OkSeedPackInfo,
} from '@/lib/desktop-bridge-types';

interface PlanCall {
  packId?: OkPackId;
  rootDir?: string;
  preview?: { skillsInstallable: boolean };
}

const planCalls: PlanCall[] = [];

const plans: Record<string, OkScaffoldPlan> = {
  'knowledge-base': {
    created: [
      { kind: 'folder', path: 'external-sources' },
      { kind: 'file', path: 'external-sources/.ok/templates/clip.md' },
      { kind: 'file', path: 'log.md' },
    ],
    skipped: [],
    warnings: [],
    packSkills: [{ name: 'open-knowledge-pack-knowledge-base', pending: true }],
  },
  'plain-notes': {
    created: [
      { kind: 'folder', path: 'daily' },
      { kind: 'file', path: 'daily/.ok/templates/daily.md' },
    ],
    skipped: [],
    warnings: [],
  },
};

let planFailure: { kind: 'invalid-root' | 'internal'; message: string } | null = null;
let planRejection: Error | null = null;

vi.doMock('@/lib/seed-client', () => ({
  seedClient: () => ({
    plan: async (options: PlanCall) => {
      planCalls.push(options);
      if (planRejection !== null) throw planRejection;
      if (planFailure !== null) {
        return { ok: false as const, error: planFailure };
      }
      const rootDir = options.rootDir;
      const base = plans[options.packId ?? 'knowledge-base'] ?? plans['knowledge-base'];
      if (base === undefined) throw new Error('missing fixture plan');
      if (rootDir === undefined) return { ok: true as const, plan: base };
      return {
        ok: true as const,
        plan: {
          ...base,
          created: base.created.map((entry) => ({ ...entry, path: `${rootDir}/${entry.path}` })),
        },
      };
    },
    apply: async () => ({ ok: true as const, result: { applied: 0, errors: [], durationMs: 1 } }),
    listPacks: async () => ({ ok: true as const, packs: PACKS }),
  }),
}));

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

const PACKS: OkSeedPackInfo[] = [
  {
    id: 'knowledge-base',
    name: 'Knowledge base',
    description: 'Structured folders for a team wiki.',
    defaultSubfolder: 'brain',
    folders: [{ path: 'external-sources', summary: 'Things you saved.' }],
    entryCounts: { files: 2, folders: 1 },
  },
  {
    id: 'plain-notes',
    name: 'Plain notes',
    description: 'A single flat folder for quick notes.',
    folders: [{ path: 'daily', summary: 'Daily journal.' }],
    entryCounts: { files: 1, folders: 1 },
  },
];

const PARENT = '/Users/test/Projects';

type CreateNewCall = { packId?: string; rootDir?: string; editors: string[] };

function makeBridge(detectedEditorIds: string[] = ['claude']) {
  const createNewCalls: CreateNewCall[] = [];
  const bridge = {
    fs: {
      defaultProjectsRoot: vi.fn(() => Promise.resolve(PARENT)),
      findEnclosingProjectRoot: vi.fn(() => Promise.resolve(null)),
      findEnclosingGitRoot: vi.fn(() => Promise.resolve(null)),
      folderState: vi.fn(() => Promise.resolve('free')),
      removeGitFolder: vi.fn(() => Promise.resolve()),
    },
    dialog: { openFolder: vi.fn(() => Promise.resolve(null)) },
    integrations: {
      status: vi.fn(() =>
        Promise.resolve({
          available: true,
          editors: [],
          path: { shellDetected: false, rcFilesToTouch: [], installed: false },
          skills: [],
          detectedEditorIds,
        }),
      ),
    },
    project: {
      createNew: vi.fn((args: CreateNewCall) => {
        createNewCalls.push(args);
        return Promise.resolve();
      }),
      recordCreateNewBannerShown: vi.fn(() => Promise.resolve()),
      open: vi.fn(() => Promise.resolve()),
    },
  } as unknown as OkDesktopBridge;
  return { bridge, createNewCalls };
}

async function renderDialog(bridge: OkDesktopBridge, initialPackId?: OkPackId) {
  const { CreateProjectDialog } = await import('./CreateProjectDialog');
  render(
    <TooltipProvider>
      <CreateProjectDialog
        open
        onOpenChange={() => {}}
        bridge={bridge}
        initialPackId={initialPackId}
        packs={PACKS}
      />
    </TooltipProvider>,
  );
  await screen.findByTestId('create-project-dialog');
  await act(async () => {
    await new Promise((resolve) => setTimeout(resolve, 0));
  });
  if (initialPackId !== undefined) {
    fireEvent.click(await screen.findByTestId('create-review-continue'));
    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 0));
    });
  }
}

async function renderDialogAtReview(bridge: OkDesktopBridge, initialPackId: OkPackId) {
  const { CreateProjectDialog } = await import('./CreateProjectDialog');
  render(
    <TooltipProvider>
      <CreateProjectDialog
        open
        onOpenChange={() => {}}
        bridge={bridge}
        initialPackId={initialPackId}
        packs={PACKS}
      />
    </TooltipProvider>,
  );
  await screen.findByTestId('create-review-body');
  await act(async () => {
    await new Promise((resolve) => setTimeout(resolve, 0));
  });
}

function clickRadio(id: string) {
  const radio = document.getElementById(id);
  if (radio === null) throw new Error(`no radio ${id}`);
  fireEvent.click(radio);
}

async function submit(name: string) {
  await userEvent.type(screen.getByTestId('create-name'), name);
  await waitFor(() => {
    expect((screen.getByTestId('create-submit') as HTMLButtonElement).disabled).toBe(false);
  });
  fireEvent.click(screen.getByTestId('create-submit'));
}

describe('CreateProjectDialog starter-pack configurator', () => {
  afterEach(() => {
    cleanup();
    planCalls.length = 0;
    planFailure = null;
    planRejection = null;
  });

  test('no pack selected renders no pack UI and no preview request', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge);
    expect(screen.queryByTestId('create-pack-section')).toBeNull();
    expect(planCalls).toEqual([]);
  });

  test('previews the pack at the project root, not its default subfolder', async () => {
    const { bridge, createNewCalls } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');

    await waitFor(() => {
      expect(planCalls.length).toBeGreaterThan(0);
    });
    expect(planCalls[0]?.rootDir).toBeUndefined();
    expect(planCalls[0]?.packId).toBe('knowledge-base');
    await waitFor(() => {
      expect(planCalls.at(-1)?.preview).toEqual({ skillsInstallable: true });
    });

    await submit('Wiki');
    await waitFor(() => {
      expect(createNewCalls).toHaveLength(1);
    });
    expect(createNewCalls[0]?.packId).toBe('knowledge-base');
    expect(createNewCalls[0]?.rootDir).toBeUndefined();
  });

  test('choosing a subfolder re-previews there and threads rootDir into createNew', async () => {
    const { bridge, createNewCalls } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');
    await waitFor(() => {
      expect(planCalls.length).toBeGreaterThan(0);
    });

    clickRadio('create-seed-root-subfolder');

    await waitFor(() => {
      expect(planCalls.at(-1)?.rootDir).toBe('brain');
    });

    await submit('Wiki');
    await waitFor(() => {
      expect(createNewCalls).toHaveLength(1);
    });
    expect(createNewCalls[0]?.rootDir).toBe('brain');
  });

  test('reports skills as uninstallable when no editor is selected', async () => {
    const { bridge } = makeBridge([]);
    await renderDialog(bridge, 'knowledge-base');
    await waitFor(() => {
      expect(planCalls.length).toBeGreaterThan(0);
    });
    expect(planCalls.at(-1)?.preview).toEqual({ skillsInstallable: false });
  });

  test('Create stays disabled while the pack preview is in an error state', async () => {
    const { bridge, createNewCalls } = makeBridge();
    planFailure = {
      kind: 'invalid-root',
      message: 'rootDir must be relative to the project directory, got: ../x',
    };
    await renderDialog(bridge, 'knowledge-base');

    await userEvent.type(screen.getByTestId('create-name'), 'Wiki');
    await screen.findByTestId('create-pack-preview-error');

    await expect(
      waitFor(
        () => {
          expect((screen.getByTestId('create-submit') as HTMLButtonElement).disabled).toBe(false);
        },
        { timeout: 1500 },
      ),
    ).rejects.toThrow();

    fireEvent.click(screen.getByTestId('create-submit'));
    expect(createNewCalls).toHaveLength(0);
  });

  test('a preview that cannot be computed at all still lets the project be created', async () => {
    const { bridge, createNewCalls } = makeBridge();
    planFailure = { kind: 'internal', message: 'Failed to fetch' };
    await renderDialogAtReview(bridge, 'knowledge-base');

    await screen.findByTestId('create-pack-preview-error');
    fireEvent.click(screen.getByTestId('create-review-continue'));
    await submit('Wiki');

    await waitFor(() => {
      expect(createNewCalls).toHaveLength(1);
    });
    expect(createNewCalls[0]?.packId).toBe('knowledge-base');
  });

  test('a rejected preview request also leaves the project creatable', async () => {
    const { bridge, createNewCalls } = makeBridge();
    planRejection = new Error("Error invoking remote method 'ok:seed:plan': read ECONNRESET");
    await renderDialogAtReview(bridge, 'knowledge-base');

    const alert = await screen.findByTestId('create-pack-preview-error');
    expect(alert.textContent).not.toContain('ECONNRESET');

    fireEvent.click(screen.getByTestId('create-review-continue'));
    await submit('Wiki');
    await waitFor(() => {
      expect(createNewCalls).toHaveLength(1);
    });
  });

  test('reopening the dialog restores the pack default subfolder', async () => {
    const { bridge } = makeBridge();
    const { CreateProjectDialog } = await import('./CreateProjectDialog');
    const props = { onOpenChange: () => {}, bridge };
    const { rerender } = render(
      <TooltipProvider>
        <CreateProjectDialog open initialPackId="knowledge-base" packs={PACKS} {...props} />
      </TooltipProvider>,
    );
    await screen.findByTestId('create-project-dialog');
    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 0));
    });
    fireEvent.click(await screen.findByTestId('create-review-continue'));

    clickRadio('create-seed-root-subfolder');
    const field = await screen.findByLabelText('Subfolder name');
    await userEvent.clear(field);
    await userEvent.type(field, 'custom-name');

    rerender(
      <TooltipProvider>
        <CreateProjectDialog open={false} initialPackId={undefined} packs={undefined} {...props} />
      </TooltipProvider>,
    );
    rerender(
      <TooltipProvider>
        <CreateProjectDialog open initialPackId="knowledge-base" packs={PACKS} {...props} />
      </TooltipProvider>,
    );
    await act(async () => {
      await new Promise((resolve) => setTimeout(resolve, 0));
    });
    fireEvent.click(await screen.findByTestId('create-review-continue'));

    clickRadio('create-seed-root-subfolder');
    expect((await screen.findByLabelText('Subfolder name')).getAttribute('value')).toBe('brain');
  });

  test('an empty subfolder name blocks Create and says why', async () => {
    const { bridge, createNewCalls } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');

    clickRadio('create-seed-root-subfolder');
    await userEvent.clear(await screen.findByLabelText('Subfolder name'));
    await userEvent.type(screen.getByTestId('create-name'), 'Wiki');

    await screen.findByTestId('create-pack-preview-error');
    await expect(
      waitFor(
        () => {
          expect((screen.getByTestId('create-submit') as HTMLButtonElement).disabled).toBe(false);
        },
        { timeout: 1500 },
      ),
    ).rejects.toThrow();

    fireEvent.click(screen.getByTestId('create-submit'));
    expect(createNewCalls).toHaveLength(0);
  });

  test('says where the pack lands when the project is an enclosing git repo', async () => {
    const { bridge } = makeBridge();
    (bridge.fs.findEnclosingGitRoot as unknown as ReturnType<typeof vi.fn>).mockResolvedValue({
      gitRoot: '/Users/test/code/acme',
    });
    await renderDialog(bridge, 'knowledge-base');

    expect(screen.queryByTestId('create-pack-promoted-note')).toBeNull();
    await userEvent.type(screen.getByTestId('create-name'), 'Team Wiki');

    const note = await screen.findByTestId('create-pack-promoted-note');
    expect(note.textContent).toContain('Team Wiki');
  });

  test('the root chooser is announced with its own heading', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');
    expect(screen.getByRole('radiogroup', { name: /Where should it live/ })).not.toBeNull();
  });

  test('picking a pack moves focus onto the review screen', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');
    fireEvent.click(screen.getByTestId('create-change-pack'));

    await userEvent.click(screen.getByRole('button', { name: /Plain notes/ }));

    await waitFor(() => {
      expect(document.activeElement).toBe(screen.getByTestId('create-review-continue'));
    });
  });

  test('continuing from review moves focus into the form', async () => {
    const { bridge } = makeBridge();
    await renderDialogAtReview(bridge, 'knowledge-base');

    fireEvent.click(screen.getByTestId('create-review-continue'));

    await waitFor(() => {
      expect(document.activeElement).toBe(screen.getByTestId('create-name'));
    });
  });

  test('opening on review focuses the primary action, not Change pack', async () => {
    const { bridge } = makeBridge();
    await renderDialogAtReview(bridge, 'knowledge-base');

    await waitFor(() => {
      expect(document.activeElement).toBe(screen.getByTestId('create-review-continue'));
    });
    expect(document.activeElement).not.toBe(screen.getByTestId('create-change-pack'));
  });

  test('Change pack moves focus into the grid it opens', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');

    fireEvent.click(screen.getByTestId('create-change-pack'));

    await waitFor(() => {
      const cards = document.querySelectorAll('[data-slot="pack-card"]');
      expect(cards.length).toBeGreaterThan(0);
      expect(document.activeElement).toBe(cards[0]);
    });
  });

  test('each step announces itself to assistive tech', async () => {
    const { bridge } = makeBridge();
    await renderDialogAtReview(bridge, 'knowledge-base');

    expect(screen.getByTestId('create-step-announcer').textContent).toContain('Reviewing');

    fireEvent.click(screen.getByTestId('create-review-continue'));
    await waitFor(() => {
      expect(screen.getByTestId('create-step-announcer').textContent).toContain('Project details');
    });
  });

  test('a typed project name survives a trip out to the grid and back', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');

    await userEvent.type(screen.getByTestId('create-name'), 'Team Wiki');
    fireEvent.click(screen.getByTestId('create-change-pack'));
    await userEvent.click(await screen.findByRole('button', { name: /Plain notes/ }));
    fireEvent.click(await screen.findByTestId('create-review-continue'));

    expect((await screen.findByTestId('create-name')).getAttribute('value')).toBe('Team Wiki');
  });

  test('an unresolved pack id opens the grid rather than a half-built review', async () => {
    const { bridge } = makeBridge();
    const { CreateProjectDialog } = await import('./CreateProjectDialog');
    render(
      <TooltipProvider>
        <CreateProjectDialog
          open
          onOpenChange={() => {}}
          bridge={bridge}
          initialPackId={'no-such-pack' as OkPackId}
          packs={PACKS}
        />
      </TooltipProvider>,
    );
    await screen.findByTestId('create-project-dialog');

    await screen.findByRole('button', { name: /Plain notes/ });
    expect(screen.queryByTestId('create-review-continue')).toBeNull();
  });

  test('switching packs from the grid does not strand review on a subfolder error', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');

    clickRadio('create-seed-root-subfolder');
    await waitFor(() => {
      expect(planCalls.at(-1)?.rootDir).toBe('brain');
    });

    fireEvent.click(screen.getByTestId('create-change-pack'));
    await userEvent.click(await screen.findByRole('button', { name: /Plain notes/ }));

    await screen.findByTestId('create-review-body');
    expect(screen.queryByTestId('create-pack-preview-error')).toBeNull();
    await screen.findByText('daily/');
  });

  test('re-picking the same pack from the grid keeps the subfolder choice', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');

    clickRadio('create-seed-root-subfolder');
    await waitFor(() => {
      expect(planCalls.at(-1)?.rootDir).toBe('brain');
    });

    fireEvent.click(screen.getByTestId('create-change-pack'));
    await userEvent.click(await screen.findByRole('button', { name: /Knowledge base/ }));

    await screen.findByTestId('create-review-body');
    fireEvent.click(screen.getByTestId('create-review-continue'));
    await screen.findByTestId('create-project-form');

    expect(
      document.getElementById('create-seed-root-subfolder')?.getAttribute('aria-checked'),
    ).toBe('true');
    await waitFor(() => {
      expect(planCalls.at(-1)?.rootDir).toBe('brain');
    });
  });

  test('the grid has no route back to review — only Cancel, which closes', async () => {
    const onOpenChange = vi.fn(() => {});
    const { bridge } = makeBridge();
    const { CreateProjectDialog } = await import('./CreateProjectDialog');
    render(
      <TooltipProvider>
        <CreateProjectDialog
          open
          onOpenChange={onOpenChange}
          bridge={bridge}
          initialPackId="knowledge-base"
          packs={PACKS}
        />
      </TooltipProvider>,
    );
    await screen.findByTestId('create-review-body');

    expect(screen.queryByTestId('create-cancel')).toBeNull();
    fireEvent.click(screen.getByTestId('create-change-pack'));

    await screen.findByRole('button', { name: /Plain notes/ });
    expect(screen.queryByTestId('create-change-pack')).toBeNull();

    fireEvent.click(screen.getByTestId('create-cancel'));
    expect(onOpenChange).toHaveBeenCalledWith(false);
  });

  test('the configure screen names the skills the AI-tools box decides', async () => {
    const { bridge } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');

    const note = await screen.findByTestId('create-pack-skills-note');
    expect(note.textContent).toContain('1 skill');
    expect(note.textContent).toContain('installs');

    await userEvent.click(screen.getByRole('checkbox'));

    await waitFor(() => {
      const after = screen.getByTestId('create-pack-skills-note');
      expect(after.textContent).toContain('1 skill');
      expect(after.textContent).toContain("won't be installed");
    });
  });

  test('the manifest renders on review and not on the configure screen', async () => {
    const { bridge } = makeBridge();
    await renderDialogAtReview(bridge, 'knowledge-base');

    await screen.findByText('external-sources/');

    fireEvent.click(screen.getByTestId('create-review-continue'));
    await screen.findByTestId('create-name');
    expect(screen.queryByText('external-sources/')).toBeNull();
  });

  test('Change pack swaps the configured pack without leaving the dialog', async () => {
    const { bridge, createNewCalls } = makeBridge();
    await renderDialog(bridge, 'knowledge-base');
    await waitFor(() => {
      expect(planCalls.length).toBeGreaterThan(0);
    });

    fireEvent.click(screen.getByTestId('create-change-pack'));
    expect(screen.queryByTestId('create-submit')).toBeNull();

    await userEvent.click(screen.getByRole('button', { name: /Plain notes/ }));

    await waitFor(() => {
      expect(planCalls.at(-1)?.packId).toBe('plain-notes');
    });
    await screen.findByText('daily/');

    fireEvent.click(screen.getByTestId('create-review-continue'));
    await submit('Notes');
    await waitFor(() => {
      expect(createNewCalls).toHaveLength(1);
    });
    expect(createNewCalls[0]?.packId).toBe('plain-notes');
  });
});