@polderlabs/bizar 4.5.2 → 4.7.1

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

@@ -0,0 +1,264 @@
+/**
+ * tests/digest-store.test.mjs
+ *
+ * v4.8.0 — Tests for the digest store CRUD operations.
+ *
+ * Verifies:
+ *   - generateWeeklyDigest returns valid markdown
+ *   - saveDigest writes file to expected paths
+ *   - listDigests returns sorted by date
+ *   - getDigest reads back the saved content
+ *   - deleteDigest removes the file
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir, homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs';
+
+// Point the store to a temp directory
+const storeHome = join(tmpdir(), `bizar-digest-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');
+
+describe('digest-store', () => {
+  beforeEach(() => {
+    mkdirSync(storeHome, { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(storeHome, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  // ── computeWeekRange ──────────────────────────────────────────────────────
+
+  describe('computeWeekRange', () => {
+    it('returns last 7 days when no args given', () => {
+      const { weekStart, weekEnd } = DIGEST_STORE.computeWeekRange();
+      assert.ok(typeof weekStart === 'string');
+      assert.ok(typeof weekEnd === 'string');
+      assert.match(weekStart, /^\d{4}-\d{2}-\d{2}$/);
+      assert.match(weekEnd, /^\d{4}-\d{2}-\d{2}$/);
+      // weekEnd should be >= weekStart
+      assert.ok(weekEnd >= weekStart);
+    });
+
+    it('returns the specified week range', () => {
+      const { weekStart, weekEnd } = DIGEST_STORE.computeWeekRange('2026-06-29', '2026-07-05');
+      assert.strictEqual(weekStart, '2026-06-29');
+      assert.strictEqual(weekEnd, '2026-07-05');
+    });
+  });
+
+  // ── generateWeeklyDigest ──────────────────────────────────────────────────
+
+  describe('generateWeeklyDigest', () => {
+    it('returns valid markdown with frontmatter', async () => {
+      const result = await DIGEST_STORE.generateWeeklyDigest({
+        weekStart: '2026-06-29',
+        weekEnd: '2026-07-05',
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      assert.ok(result.markdown, 'markdown should be present');
+      assert.ok(result.markdown.startsWith('---'), 'markdown should start with frontmatter');
+      assert.ok(result.markdown.includes('Weekly Digest'), 'markdown should contain title');
+      assert.ok(result.markdown.includes('## Tasks completed'), 'markdown should have tasks section');
+      assert.ok(result.markdown.includes('## Memory notes written'), 'markdown should have memory section');
+      assert.ok(result.markdown.includes('## Chat sessions'), 'markdown should have chat section');
+      assert.ok(result.markdown.includes('## Schedules fired'), 'markdown should have schedules section');
+      assert.ok(result.markdown.includes('## Background agents completed'), 'markdown should have bg section');
+      assert.ok(result.markdown.includes('## Token usage'), 'markdown should have usage section');
+      assert.deepStrictEqual(result.sections, result.sections, 'sections object should be present');
+      assert.strictEqual(result.weekStart, '2026-06-29');
+      assert.strictEqual(result.weekEnd, '2026-07-05');
+      assert.strictEqual(result.dryRun, true);
+    });
+
+    it('defaults to last 7 days when dates omitted', async () => {
+      const result = await DIGEST_STORE.generateWeeklyDigest({
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+      assert.ok(result.markdown);
+      assert.ok(result.weekStart, 'weekStart should be present');
+      assert.ok(result.weekEnd, 'weekEnd should be present');
+    });
+
+    it('sections contain expected shapes', async () => {
+      const result = await DIGEST_STORE.generateWeeklyDigest({
+        weekStart: '2026-06-29',
+        weekEnd: '2026-07-05',
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      // All 7 section keys should be present
+      const expectedKeys = ['tasks', 'tasks-created', 'memory-writes', 'chat-sessions',
+        'schedules-fired', 'bg-agents-completed', 'usage-stats'];
+      for (const key of expectedKeys) {
+        assert.ok(key in result.sections, `section "${key}" should be present`);
+      }
+    });
+  });
+
+  // ── saveDigest ────────────────────────────────────────────────────────────
+
+  describe('saveDigest', () => {
+    it('writes digest files to expected paths', async () => {
+      const markdown = '---\ntitle: "Test"\n---\n\n# Test digest body';
+      const result = await DIGEST_STORE.saveDigest({
+        markdown,
+        weekStart: '2026-07-05',
+      });
+
+      assert.ok(result.ok);
+      assert.ok(Array.isArray(result.paths));
+      assert.ok(result.paths.length >= 1);
+
+      // Primary path should exist
+      const primaryPath = result.paths[0];
+      assert.ok(existsSync(primaryPath), `primary path should exist: ${primaryPath}`);
+      const content = readFileSync(primaryPath, 'utf8');
+      assert.ok(content.includes(markdown));
+    });
+
+    it('also writes to project vault if .obsidian exists', async () => {
+      const vaultDigests = join(storeHome, '.obsidian', 'digests');
+      mkdirSync(vaultDigests, { recursive: true });
+
+      const markdown = '---\ntitle: "Vault Test"\n---\n\n# Vault test body';
+      const result = await DIGEST_STORE.saveDigest({
+        markdown,
+        weekStart: '2026-06-29',
+        projectRoot: storeHome,
+      });
+
+      assert.ok(result.ok);
+      const vaultPath = join(vaultDigests, 'weekly-2026-06-29.md');
+      assert.ok(existsSync(vaultPath), `vault path should exist: ${vaultPath}`);
+    });
+  });
+
+  // ── listDigests ───────────────────────────────────────────────────────────
+
+  describe('listDigests', () => {
+    it('returns an empty list when no digests exist', async () => {
+      const digests = await DIGEST_STORE.listDigests();
+      assert.ok(Array.isArray(digests));
+      assert.strictEqual(digests.length, 0);
+    });
+
+    it('returns digests sorted by date descending', async () => {
+      // Create two digests out of order
+      await DIGEST_STORE.saveDigest({
+        markdown: '# Alpha',
+        weekStart: '2026-07-05',
+      });
+      await DIGEST_STORE.saveDigest({
+        markdown: '# Beta',
+        weekStart: '2026-06-28',
+      });
+
+      const digests = await DIGEST_STORE.listDigests();
+      assert.strictEqual(digests.length, 2);
+      // Should be sorted: 2026-07-05 first, then 2026-06-28
+      assert.strictEqual(digests[0].weekStart, '2026-07-05');
+      assert.strictEqual(digests[1].weekStart, '2026-06-28');
+    });
+
+    it('respects the limit parameter', async () => {
+      await DIGEST_STORE.saveDigest({ markdown: '# A', weekStart: '2026-07-05' });
+      await DIGEST_STORE.saveDigest({ markdown: '# B', weekStart: '2026-06-28' });
+      await DIGEST_STORE.saveDigest({ markdown: '# C', weekStart: '2026-06-21' });
+
+      const digests = await DIGEST_STORE.listDigests({ limit: 2 });
+      assert.strictEqual(digests.length, 2);
+    });
+  });
+
+  // ── getDigest ─────────────────────────────────────────────────────────────
+
+  describe('getDigest', () => {
+    it('returns null for non-existent path', async () => {
+      const result = await DIGEST_STORE.getDigest('/nonexistent/path.md');
+      assert.strictEqual(result, null);
+    });
+
+    it('reads back the saved digest content', async () => {
+      const markdown = '---\ntitle: "Read Test"\n---\n\n# Read test body';
+      const saveResult = await DIGEST_STORE.saveDigest({
+        markdown,
+        weekStart: '2026-07-04',
+      });
+      const primaryPath = saveResult.paths[0];
+
+      const digest = await DIGEST_STORE.getDigest(primaryPath);
+      assert.ok(digest, 'digest should be found');
+      assert.strictEqual(digest.content, markdown);
+      assert.strictEqual(digest.weekStart, '2026-07-04');
+      assert.ok(digest.sizeBytes > 0);
+      assert.strictEqual(digest.path, primaryPath);
+    });
+  });
+
+  // ── deleteDigest ──────────────────────────────────────────────────────────
+
+  describe('deleteDigest', () => {
+    it('returns ok:false for empty path', async () => {
+      const result = await DIGEST_STORE.deleteDigest(null);
+      assert.strictEqual(result.ok, false);
+    });
+
+    it('removes the digest file and index entry', async () => {
+      const markdown = '# Delete me';
+      const saveResult = await DIGEST_STORE.saveDigest({
+        markdown,
+        weekStart: '2026-07-03',
+      });
+      const primaryPath = saveResult.paths[0];
+      assert.ok(existsSync(primaryPath), 'file should exist before deletion');
+
+      const delResult = await DIGEST_STORE.deleteDigest(primaryPath);
+      assert.strictEqual(delResult.ok, true);
+      assert.strictEqual(existsSync(primaryPath), false, 'file should be removed');
+
+      // Index entry should be gone
+      const digests = await DIGEST_STORE.listDigests();
+      assert.strictEqual(digests.length, 0);
+    });
+  });
+
+  // ── generateAndSave ───────────────────────────────────────────────────────
+
+  describe('generateAndSave', () => {
+    it('generates and saves when dryRun is false', async () => {
+      const result = await DIGEST_STORE.generateAndSave({
+        weekStart: '2026-06-28',
+        weekEnd: '2026-07-04',
+        projectRoot: storeHome,
+        dryRun: false,
+      });
+
+      assert.ok(result.markdown);
+      assert.ok(result.saveResult);
+      assert.ok(result.saveResult.ok);
+      assert.ok(result.saveResult.paths.length >= 1);
+    });
+
+    it('does not save when dryRun is true', async () => {
+      const result = await DIGEST_STORE.generateAndSave({
+        weekStart: '2026-06-28',
+        weekEnd: '2026-07-04',
+        projectRoot: storeHome,
+        dryRun: true,
+      });
+
+      assert.ok(result.markdown);
+      assert.strictEqual(result.saveResult, undefined);
+    });
+  });
+});

package/bizar-dash/tests/hooks/useModal.test.tsx

@@ -0,0 +1,84 @@
+import { render, screen, renderHook } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect } from 'vitest';
+import { ModalProvider, useModal } from '../../src/web/components/Modal';
+
+function TestHarness() {
+  const modal = useModal();
+  return (
+    <div>
+      <button onClick={() => modal.open({ title: 'Dialog', children: <p>Content</p> })}>
+        Open
+      </button>
+      <span data-testid="modal-open">{String(modal.isModalOpen)}</span>
+    </div>
+  );
+}
+
+describe('useModal', () => {
+  it('isModalOpen starts as false', () => {
+    render(
+      <ModalProvider>
+        <TestHarness />
+      </ModalProvider>,
+    );
+
+    expect(screen.getByTestId('modal-open')).toHaveTextContent('false');
+  });
+
+  it('open() renders a modal dialog', async () => {
+    const user = userEvent.setup();
+    render(
+      <ModalProvider>
+        <TestHarness />
+      </ModalProvider>,
+    );
+
+    await user.click(screen.getByText('Open'));
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+    expect(screen.getByText('Dialog')).toBeInTheDocument();
+    expect(screen.getByText('Content')).toBeInTheDocument();
+  });
+
+  it('close() removes the dialog', async () => {
+    const user = userEvent.setup();
+
+    function HarnessWithClose() {
+      const modal = useModal();
+      return (
+        <div>
+          <button
+            onClick={() =>
+              modal.open({
+                title: 'Dialog',
+                children: <p>Content</p>,
+                footer: <button onClick={() => modal.close()}>Close Modal</button>,
+              })
+            }
+          >
+            Open
+          </button>
+        </div>
+      );
+    }
+
+    render(
+      <ModalProvider>
+        <HarnessWithClose />
+      </ModalProvider>,
+    );
+
+    await user.click(screen.getByText('Open'));
+    expect(screen.getByRole('dialog')).toBeInTheDocument();
+
+    await user.click(screen.getByText('Close Modal'));
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('returns fallback api when no provider is present', () => {
+    const { result } = renderHook(() => useModal());
+    expect(result.current.isModalOpen).toBe(false);
+    expect(result.current.open({ children: <p>test</p> })).toBe('');
+    expect(() => result.current.close()).not.toThrow();
+  });
+});

package/bizar-dash/tests/hooks/useToast.test.tsx

@@ -0,0 +1,50 @@
+import { render, screen, act, renderHook } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi } from 'vitest';
+import { ToastProvider, useToast } from '../../src/web/components/Toast';
+
+function TestHarness() {
+  const toast = useToast();
+  return (
+    <div>
+      <button onClick={() => toast.success('Success toast body')}>Trigger Success</button>
+      <button onClick={() => toast.error('Error toast body')}>Trigger Error</button>
+      <button onClick={() => toast.info('Info toast body')}>Trigger Info</button>
+    </div>
+  );
+}
+
+describe('useToast', () => {
+  it('calling success() renders a toast', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <TestHarness />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByText('Trigger Success'));
+    expect(screen.getByText('Success toast body')).toBeInTheDocument();
+  });
+
+  it('calling error() renders an error toast', async () => {
+    const user = userEvent.setup();
+    render(
+      <ToastProvider>
+        <TestHarness />
+      </ToastProvider>,
+    );
+
+    await user.click(screen.getByText('Trigger Error'));
+    expect(screen.getByText('Error toast body')).toBeInTheDocument();
+  });
+
+  it('returns fallback api when no provider is present', () => {
+    const { result } = renderHook(() => useToast());
+    expect(result.current.toasts).toEqual([]);
+    expect(result.current.isModalOpen).toBeUndefined();
+    // Calling methods should not throw
+    expect(() => result.current.show('test')).not.toThrow();
+    expect(() => result.current.dismiss(1)).not.toThrow();
+  });
+});

package/bizar-dash/tests/lib/i18n.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { t, setLocale, getLocale } from '../../src/web/lib/i18n';
+
+describe('i18n', () => {
+  it('t() returns the key if no translation exists', () => {
+    expect(t('nonexistent.key')).toBe('nonexistent.key');
+  });
+
+  it('t() returns translation if registered', () => {
+    setLocale('en', { 'hello': 'Hello World' });
+    expect(t('hello')).toBe('Hello World');
+  });
+
+  it('setLocale() switches locale and getLocale() reflects it', () => {
+    setLocale('en');
+    expect(getLocale()).toBe('en');
+
+    setLocale('fr');
+    expect(getLocale()).toBe('fr');
+
+    setLocale('de', { greet: 'Hallo' });
+    expect(getLocale()).toBe('de');
+    expect(t('greet')).toBe('Hallo');
+  });
+
+  it('supports variable interpolation with {varName} syntax', () => {
+    setLocale('en', {
+      greeting: 'Hello, {name}!',
+      ageMsg: '{name} is {age} years old',
+    });
+    expect(t('greeting', { name: 'World' })).toBe('Hello, World!');
+    expect(t('ageMsg', { name: 'Alice', age: 30 })).toBe('Alice is 30 years old');
+  });
+
+  it('falls back to en translations when current locale is missing a key', () => {
+    setLocale('en', { shared: 'English text' });
+    setLocale('fr', { local: 'Texte français' });
+
+    // 'shared' is not in fr, should fall back to en
+    expect(t('shared')).toBe('English text');
+    // 'local' is in fr
+    expect(t('local')).toBe('Texte français');
+    // Neither locale has this
+    expect(t('missing')).toBe('missing');
+  });
+});

package/bizar-dash/tests/lib/utils.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  cn,
+  formatRelative,
+  formatTime,
+  truncate,
+  debounce,
+  statusBadgeKind,
+  hashText,
+  autoTitleFromContent,
+} from '../../src/web/lib/utils';
+
+describe('cn', () => {
+  it('joins class names', () => {
+    expect(cn('a', 'b')).toBe('a b');
+  });
+
+  it('filters falsy values', () => {
+    expect(cn('a', false, null, undefined, 'b')).toBe('a b');
+  });
+
+  it('returns empty string with no args', () => {
+    expect(cn()).toBe('');
+  });
+});
+
+describe('formatRelative', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(formatRelative(null)).toBe('');
+    expect(formatRelative(undefined)).toBe('');
+  });
+
+  it('returns "just now" for recent timestamps', () => {
+    expect(formatRelative(Date.now())).toBe('just now');
+    expect(formatRelative(Date.now() + 1000)).toBe('just now');
+  });
+
+  it('returns minutes', () => {
+    const fiveMinAgo = Date.now() - 5 * 60_000;
+    expect(formatRelative(fiveMinAgo)).toBe('5m ago');
+  });
+
+  it('returns hours', () => {
+    const twoHoursAgo = Date.now() - 2 * 3_600_000;
+    expect(formatRelative(twoHoursAgo)).toBe('2h ago');
+  });
+
+  it('returns days', () => {
+    const threeDaysAgo = Date.now() - 3 * 86_400_000;
+    expect(formatRelative(threeDaysAgo)).toBe('3d ago');
+  });
+
+  it('returns localized date for older timestamps', () => {
+    const oldDate = Date.now() - 30 * 86_400_000;
+    const result = formatRelative(oldDate);
+    expect(result).not.toMatch(/^(just now|\d+[mhd] ago)$/);
+    expect(result.length).toBeGreaterThan(0);
+  });
+});
+
+describe('formatTime', () => {
+  it('returns empty for null/undefined', () => {
+    expect(formatTime(null)).toBe('');
+    expect(formatTime(undefined)).toBe('');
+  });
+
+  it('formats a Date object', () => {
+    const d = new Date('2024-06-15T12:00:00');
+    const result = formatTime(d);
+    expect(result).toBe(d.toLocaleString());
+  });
+
+  it('formats a timestamp number', () => {
+    const ts = new Date('2024-06-15T12:00:00').getTime();
+    expect(formatTime(ts)).toBe(new Date(ts).toLocaleString());
+  });
+});
+
+describe('truncate', () => {
+  it('returns empty for null/undefined', () => {
+    expect(truncate(null)).toBe('');
+    expect(truncate(undefined)).toBe('');
+  });
+
+  it('returns string as-is when shorter than max', () => {
+    expect(truncate('hello', 10)).toBe('hello');
+  });
+
+  it('truncates with ellipsis when longer than max', () => {
+    expect(truncate('hello world this is long', 10)).toBe('hello worl…');
+  });
+
+  it('uses default max of 160', () => {
+    const short = 'a'.repeat(100);
+    expect(truncate(short)).toBe(short);
+    const long = 'a'.repeat(200);
+    expect(truncate(long)).toHaveLength(161);
+    expect(truncate(long)).toMatch(/…$/);
+  });
+});
+
+describe('debounce', () => {
+  it('delays execution', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+
+    debounced();
+    expect(fn).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(100);
+    expect(fn).toHaveBeenCalledOnce();
+    vi.useRealTimers();
+  });
+
+  it('calls with the latest arguments', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+
+    debounced('a');
+    debounced('b');
+    vi.advanceTimersByTime(100);
+
+    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledWith('b');
+    vi.useRealTimers();
+  });
+});
+
+describe('statusBadgeKind', () => {
+  it('returns success for approved/done', () => {
+    expect(statusBadgeKind('approved')).toBe('success');
+    expect(statusBadgeKind('done')).toBe('success');
+  });
+
+  it('returns empty for draft/queued', () => {
+    expect(statusBadgeKind('draft')).toBe('');
+    expect(statusBadgeKind('queued')).toBe('');
+  });
+
+  it('returns info for in-progress/doing', () => {
+    expect(statusBadgeKind('in-progress')).toBe('info');
+    expect(statusBadgeKind('doing')).toBe('info');
+  });
+
+  it('returns error for rejected', () => {
+    expect(statusBadgeKind('rejected')).toBe('error');
+  });
+
+  it('returns accent for unknown statuses', () => {
+    expect(statusBadgeKind('unknown')).toBe('accent');
+  });
+});
+
+describe('hashText', () => {
+  it('returns a string', () => {
+    expect(typeof hashText('hello')).toBe('string');
+  });
+
+  it('is deterministic', () => {
+    expect(hashText('hello')).toBe(hashText('hello'));
+  });
+
+  it('differs for different inputs', () => {
+    expect(hashText('hello')).not.toBe(hashText('world'));
+  });
+});
+
+describe('autoTitleFromContent', () => {
+  it('extracts first non-empty line', () => {
+    expect(autoTitleFromContent('Hello world')).toBe('Hello world');
+  });
+
+  it('strips markdown heading markers', () => {
+    expect(autoTitleFromContent('## My Feature')).toBe('My Feature');
+  });
+
+  it('generates fallback title when body is empty', () => {
+    const result = autoTitleFromContent('');
+    expect(result).toMatch(/^Untitled task/);
+  });
+
+  it('returns empty when fallback is false and body is empty', () => {
+    expect(autoTitleFromContent('', false)).toBe('');
+  });
+
+  it('truncates long first lines', () => {
+    const long = 'a'.repeat(100);
+    const result = autoTitleFromContent(long);
+    expect(result.length).toBeLessThan(long.length);
+    expect(result).toMatch(/…$/);
+  });
+});