@polderlabs/bizar 4.5.2 → 4.7.1

package/bizar-dash/tests/components/Button.test.tsx

@@ -0,0 +1,41 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { Button } from '../../src/web/components/Button';
+
+describe('Button', () => {
+  it('renders text', () => {
+    render(<Button>Click me</Button>);
+    expect(screen.getByRole('button', { name: 'Click me' })).toBeInTheDocument();
+  });
+
+  it('fires onClick when clicked', async () => {
+    const onClick = vi.fn();
+    const user = userEvent.setup();
+    render(<Button onClick={onClick}>Click</Button>);
+    await user.click(screen.getByRole('button'));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('is disabled when disabled prop is set', () => {
+    render(<Button disabled>Disabled</Button>);
+    expect(screen.getByRole('button')).toBeDisabled();
+  });
+
+  it('shows loading state and disables button', () => {
+    render(<Button loading>Saving</Button>);
+    const btn = screen.getByRole('button');
+    expect(btn).toBeDisabled();
+    expect(btn.querySelector('.btn-spinner')).toBeInTheDocument();
+  });
+
+  it('applies variant classes', () => {
+    const { container } = render(<Button variant="primary">Primary</Button>);
+    expect(container.firstChild).toHaveClass('btn-primary');
+  });
+
+  it('applies size classes', () => {
+    const { container } = render(<Button size="lg">Large</Button>);
+    expect(container.firstChild).toHaveClass('btn-size-lg');
+  });
+});

package/bizar-dash/tests/components/Card.test.tsx

@@ -0,0 +1,42 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { Card, CardTitle, CardMeta } from '../../src/web/components/Card';
+
+describe('Card', () => {
+  it('renders children', () => {
+    render(<Card>Hello</Card>);
+    expect(screen.getByText('Hello')).toBeInTheDocument();
+  });
+
+  it('has expected class name', () => {
+    const { container } = render(<Card>Test</Card>);
+    expect(container.firstChild).toHaveClass('card');
+  });
+
+  it('applies variant classes', () => {
+    const { container, rerender } = render(<Card variant="elevated">Test</Card>);
+    expect(container.firstChild).toHaveClass('card-elevated');
+
+    rerender(<Card variant="outlined">Test</Card>);
+    expect(container.firstChild).toHaveClass('card-outlined');
+
+    rerender(<Card variant="filled">Test</Card>);
+    expect(container.firstChild).toHaveClass('card-filled');
+  });
+
+  it('renders CardTitle and CardMeta', () => {
+    render(
+      <Card>
+        <CardTitle>My Title</CardTitle>
+        <CardMeta>Meta info</CardMeta>
+      </Card>,
+    );
+    expect(screen.getByText('My Title')).toBeInTheDocument();
+    expect(screen.getByText('Meta info')).toBeInTheDocument();
+  });
+
+  it('sets interactive class when interactive prop is true', () => {
+    const { container } = render(<Card interactive>Clickable</Card>);
+    expect(container.firstChild).toHaveClass('card-interactive');
+  });
+});

package/bizar-dash/tests/components/Modal.test.tsx

@@ -0,0 +1,104 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { ModalProvider, useModal } from '../../src/web/components/Modal';
+
+function ModalHarness() {
+  const modal = useModal();
+  return (
+    <div>
+      <button onClick={() => modal.open({ title: 'Dialog', children: <p>Content</p> })}>
+        Open
+      </button>
+    </div>
+  );
+}
+
+function ModalHarnessWithClose() {
+  const modal = useModal();
+  return (
+    <div>
+      <button
+        onClick={() =>
+          modal.open({
+            title: 'Dialog',
+            children: <p>Content</p>,
+            footer: <button onClick={() => modal.close()}>Close</button>,
+          })
+        }
+      >
+        Open
+      </button>
+    </div>
+  );
+}
+
+describe('Modal', () => {
+  it('renders when open', async () => {
+    const user = userEvent.setup();
+    render(
+      <ModalProvider>
+        <ModalHarness />
+      </ModalProvider>,
+    );
+
+    await user.click(screen.getByText('Open'));
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(screen.getByText('Dialog')).toBeInTheDocument();
+    expect(screen.getByText('Content')).toBeInTheDocument();
+  });
+
+  it('does not render dialog when closed', () => {
+    render(
+      <ModalProvider>
+        <ModalHarness />
+      </ModalProvider>,
+    );
+
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('has role="dialog"', async () => {
+    const user = userEvent.setup();
+    render(
+      <ModalProvider>
+        <ModalHarness />
+      </ModalProvider>,
+    );
+
+    await user.click(screen.getByText('Open'));
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+  });
+
+  it('closes on Escape key', async () => {
+    const user = userEvent.setup();
+    render(
+      <ModalProvider>
+        <ModalHarness />
+      </ModalProvider>,
+    );
+
+    await user.click(screen.getByText('Open'));
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+
+    await user.keyboard('{Escape}');
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('closes when clicking the backdrop', async () => {
+    const user = userEvent.setup();
+    render(
+      <ModalProvider>
+        <ModalHarness />
+      </ModalProvider>,
+    );
+
+    await user.click(screen.getByText('Open'));
+    const dialog = screen.getByRole('dialog');
+    expect(dialog).toBeInTheDocument();
+
+    const backdrop = dialog.parentElement!;
+    await user.click(backdrop);
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/components/Spinner.test.tsx

@@ -0,0 +1,32 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { Spinner } from '../../src/web/components/Spinner';
+
+describe('Spinner', () => {
+  it('renders with default size', () => {
+    const { container } = render(<Spinner />);
+    const spinner = container.firstChild;
+    expect(spinner).toHaveClass('spinner');
+    expect(spinner).toHaveClass('spinner-md');
+  });
+
+  it('renders with custom size', () => {
+    const { container } = render(<Spinner size="lg" />);
+    expect(container.firstChild).toHaveClass('spinner-lg');
+  });
+
+  it('has role="status" for accessibility', () => {
+    render(<Spinner />);
+    expect(screen.getByRole('status')).toBeInTheDocument();
+  });
+
+  it('has default aria-label', () => {
+    render(<Spinner />);
+    expect(screen.getByRole('status')).toHaveAttribute('aria-label', 'Loading');
+  });
+
+  it('accepts a custom aria-label', () => {
+    render(<Spinner label="Please wait" />);
+    expect(screen.getByRole('status')).toHaveAttribute('aria-label', 'Please wait');
+  });
+});

package/bizar-dash/tests/components/StatusBadge.test.tsx

@@ -0,0 +1,35 @@
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { StatusBadge } from '../../src/web/components/StatusBadge';
+
+describe('StatusBadge', () => {
+  it('renders with default neutral kind', () => {
+    const { container } = render(<StatusBadge>Default</StatusBadge>);
+    expect(container.firstChild).toHaveClass('badge');
+    expect(container.firstChild).toHaveClass('badge-neutral');
+  });
+
+  it('renders with each variant class', () => {
+    const variants = ['success', 'warning', 'error', 'info', 'accent'] as const;
+    for (const kind of variants) {
+      const { container, unmount } = render(<StatusBadge kind={kind}>{kind}</StatusBadge>);
+      expect(container.firstChild).toHaveClass(`badge-${kind}`);
+      unmount();
+    }
+  });
+
+  it('renders children', () => {
+    render(<StatusBadge>Active</StatusBadge>);
+    expect(screen.getByText('Active')).toBeInTheDocument();
+  });
+
+  it('shows dot element when dot prop is true', () => {
+    const { container } = render(<StatusBadge dot>With dot</StatusBadge>);
+    expect(container.querySelector('.badge-dot')).toBeInTheDocument();
+  });
+
+  it('does not show dot when dot prop is false', () => {
+    const { container } = render(<StatusBadge>No dot</StatusBadge>);
+    expect(container.querySelector('.badge-dot')).not.toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/components/Toast.test.tsx

@@ -0,0 +1,108 @@
+import { render, screen, act, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { ToastContainer, ToastProvider, useToast } from '../../src/web/components/Toast';
+
+function ToastHarness() {
+  const toast = useToast();
+  return (
+    <div>
+      <button onClick={() => toast.show('Info message')}>Show Info</button>
+      <button onClick={() => toast.success('Success!')}>Show Success</button>
+      <button onClick={() => toast.error('Error!')}>Show Error</button>
+    </div>
+  );
+}
+
+describe('ToastContainer', () => {
+  it('renders toast with message', () => {
+    render(
+      <ToastContainer
+        toasts={[{ id: 1, kind: 'info', message: 'Test toast' }]}
+        onDismiss={() => {}}
+      />,
+    );
+    expect(screen.getByText('Test toast')).toBeInTheDocument();
+  });
+
+  it('has role="alert" and aria-live="assertive"', () => {
+    render(
+      <ToastContainer
+        toasts={[{ id: 1, kind: 'info', message: 'Accessible toast' }]}
+        onDismiss={() => {}}
+      />,
+    );
+    const toast = screen.getByRole('alert');
+    expect(toast).toBeInTheDocument();
+    expect(toast).toHaveAttribute('aria-live', 'assertive');
+  });
+});
+
+describe('ToastProvider + useToast', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('displays a toast when show is called', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <ToastHarness />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByText('Show Info'));
+    expect(screen.getByText('Info message')).toBeInTheDocument();
+  });
+
+  it('displays multiple toasts stacked', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <ToastHarness />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByText('Show Success'));
+    await user.click(screen.getByText('Show Error'));
+
+    expect(screen.getByText('Success!')).toBeInTheDocument();
+    expect(screen.getByText('Error!')).toBeInTheDocument();
+  });
+
+  it('auto-dismisses after the default timeout', () => {
+    // Use fireEvent (synchronous) instead of userEvent to avoid
+    // timer conflicts with vi.useFakeTimers
+    vi.useFakeTimers();
+
+    render(
+      <ToastProvider>
+        <ToastHarness />
+      </ToastProvider>,
+    );
+
+    fireEvent.click(screen.getByText('Show Info'));
+    expect(screen.getByText('Info message')).toBeInTheDocument();
+
+    act(() => {
+      vi.advanceTimersByTime(4000);
+    });
+
+    expect(screen.queryByText('Info message')).not.toBeInTheDocument();
+  });
+
+  it('dismisses a toast when dismiss button is clicked', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <ToastHarness />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByText('Show Info'));
+    expect(screen.getByText('Info message')).toBeInTheDocument();
+
+    await user.click(screen.getByLabelText('Dismiss'));
+    expect(screen.queryByText('Info message')).not.toBeInTheDocument();
+  });
+});

package/bizar-dash/tests/digest-generation.test.mjs

@@ -0,0 +1,191 @@
+/**
+ * tests/digest-generation.test.mjs
+ *
+ * v4.8.0 — End-to-end tests for digest generation.
+ *
+ * Verifies:
+ *   - Creating tasks then generating a digest includes task info
+ *   - dryRun does not save any files
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, existsSync, writeFileSync } from 'node:fs';
+
+// Point stores to temp directories
+const storeHome = join(tmpdir(), `bizar-digest-gen-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+process.env.BIZAR_STORE_HOME = storeHome;
+
+const DIGEST_STORE = await import('../src/server/digest-store.mjs');
+
+// We import tasksStore to create tasks that should appear in the digest
+let tasksStore;
+
+describe('digest-generation', () => {
+  beforeEach(async () => {
+    mkdirSync(storeHome, { recursive: true });
+
+    // Create the project's .obsidian directory with some notes
+    const obsidianDir = join(storeHome, '.obsidian');
+    const dailyDir = join(obsidianDir, 'daily');
+    const decisionsDir = join(obsidianDir, 'decisions');
+    mkdirSync(dailyDir, { recursive: true });
+    mkdirSync(decisionsDir, { recursive: true });
+
+    // Write some memory notes "within the week"
+    writeFileSync(join(dailyDir, '2026-07-01.md'),
+      '---\ntitle: "Daily Note Jul 1"\n---\n\nWorked on authentication flow.');
+    writeFileSync(join(decisionsDir, 'use-sqlite.md'),
+      '---\ntitle: "Use SQLite"\n---\n\nDecision to use SQLite for local storage.');
+  });
+
+  afterEach(() => {
+    try { rmSync(storeHome, { recursive: true, force: true }); } catch { /* ignore */ }
+    DIGEST_STORE.__resetStoreForTests();
+  });
+
+  // ── Basic generation ──────────────────────────────────────────────────────
+
+  describe('basic generation', () => {
+    it('generates markdown with all expected sections', async () => {
+      const result = await DIGEST_STORE.generateWeeklyDigest({
+        weekStart: '2026-06-28',
+        weekEnd: '2026-07-04',
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      assert.ok(result.markdown);
+      // Check frontmatter
+      assert.ok(result.markdown.includes('type: digest'));
+      assert.ok(result.markdown.includes('weekStart: 2026-06-28'));
+      assert.ok(result.markdown.includes('weekEnd: 2026-07-04'));
+
+      // Check all section headers present
+      const sections = [
+        'Tasks completed',
+        'Tasks created',
+        'Memory notes written',
+        'Chat sessions',
+        'Schedules fired',
+        'Background agents completed',
+        'Token usage',
+      ];
+      for (const s of sections) {
+        assert.ok(result.markdown.includes(`## ${s}`), `section "${s}" should have a header`);
+      }
+
+      // Check footer
+      assert.ok(result.markdown.includes('BizarHarness v4.8.0'));
+    });
+
+    it('memory-writes section is populated from vault state', async () => {
+      // Use a week range that includes "right now" so the notes written
+      // in beforeEach (which have the current mtime) are picked up.
+      const now = new Date();
+      const weekStart = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000)
+        .toISOString().slice(0, 10);
+      const weekEnd = new Date(now.getTime() + 1 * 24 * 60 * 60 * 1000)
+        .toISOString().slice(0, 10);
+
+      const result = await DIGEST_STORE.generateWeeklyDigest({
+        weekStart,
+        weekEnd,
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      // memory-writes section should contain our test notes (since they
+      // were just created and fall within the dynamic date range)
+      const memorySection = result.sections['memory-writes'];
+      assert.ok(Array.isArray(memorySection), 'memory-writes should be an array');
+      assert.ok(memorySection.length > 0, 'should include at least one memory note');
+      // At least one note should reference the files we created
+      const hasDaily = memorySection.some((n) => n.relPath.includes('daily'));
+      const hasDecisions = memorySection.some((n) => n.relPath.includes('decisions'));
+      assert.ok(hasDaily || hasDecisions, 'should include notes from our test vault');
+    });
+  });
+
+  // ── dryRun behavior ───────────────────────────────────────────────────────
+
+  describe('dryRun', () => {
+    it('does not save files when dryRun is true', async () => {
+      const result = await DIGEST_STORE.generateAndSave({
+        weekStart: '2026-06-28',
+        weekEnd: '2026-07-04',
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      // saveResult should not be present
+      assert.strictEqual(result.saveResult, undefined, 'saveResult should be undefined in dry run');
+
+      // No digest files should exist
+      const prefix = 'weekly-';
+      const digestsDir = join(storeHome, 'digests');
+      if (existsSync(digestsDir)) {
+        const { readdirSync } = await import('node:fs');
+        const files = readdirSync(digestsDir);
+        const digestFiles = files.filter((f) => f.startsWith(prefix));
+        assert.strictEqual(digestFiles.length, 0, 'no digest files should exist after dry run');
+      }
+    });
+
+    it('saves files when dryRun is false', async () => {
+      const result = await DIGEST_STORE.generateAndSave({
+        weekStart: '2026-06-21',
+        weekEnd: '2026-06-27',
+        projectRoot: storeHome,
+        dryRun: false,
+      });
+
+      assert.ok(result.saveResult, 'saveResult should be present');
+      assert.ok(result.saveResult.ok);
+      assert.ok(result.saveResult.paths.length >= 1);
+
+      // File should exist on disk
+      for (const p of result.saveResult.paths) {
+        assert.ok(existsSync(p), `digest file should exist: ${p}`);
+      }
+    });
+  });
+
+  // ── Markdown format ───────────────────────────────────────────────────────
+
+  describe('markdown format', () => {
+    it('produces parseable frontmatter', async () => {
+      const result = await DIGEST_STORE.generateWeeklyDigest({
+        weekStart: '2026-06-28',
+        weekEnd: '2026-07-04',
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      // Extract frontmatter between --- markers
+      const lines = result.markdown.split('\n');
+      assert.strictEqual(lines[0], '---', 'should start with frontmatter delimiter');
+      const endIdx = lines.indexOf('---', 1);
+      assert.ok(endIdx > 1, 'should have closing frontmatter delimiter');
+
+      const fm = lines.slice(1, endIdx);
+      const titleLine = fm.find((l) => l.startsWith('title:'));
+      assert.ok(titleLine, 'frontmatter should have title');
+      assert.ok(titleLine.includes('Weekly Digest'), 'title should mention Weekly Digest');
+    });
+
+    it('has a readable human date in the header', async () => {
+      const result = await DIGEST_STORE.generateWeeklyDigest({
+        weekStart: '2026-06-28',
+        weekEnd: '2026-07-04',
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      // The markdown should have a **Week:** line
+      assert.ok(result.markdown.includes('**Week:**'), 'should have week header');
+    });
+  });
+});