@startsimpli/integrations 0.1.6 → 0.2.1

package/src/__tests__/corpus-tracker.test.tsx

@@ -0,0 +1,250 @@
+/**
+ * THE TRACKING SURFACE, rendered (bd startsim-768w.38.25).
+ *
+ * The screen makes one claim — "this is what is still owed" — and every case
+ * below is a way that claim could be false on screen while the data underneath
+ * is fine: a closed item shown as outstanding, an item with no owner rendered
+ * as though it had one, a filter that did nothing, a row with no traceable
+ * source, a run that closed something and did not say why.
+ */
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it, vi } from 'vitest';
+
+import { TrackerPage } from '../components/pages/TrackerPage';
+import type {
+  Commitment,
+  CommitmentQuery,
+  CommitmentTrackerApi,
+  CorpusPage,
+} from '../corpus/types';
+
+const NOW = Date.parse('2026-08-10T12:00:00Z');
+const SCOPE = { orgId: 'tandem' };
+
+function commitment(overrides: Partial<Commitment> & { externalId: string; title: string }): Commitment {
+  return {
+    id: overrides.externalId,
+    dedupeKey: overrides.externalId.replace('commit:', ''),
+    subtype: 'action',
+    detail: '',
+    status: 'open',
+    subjectKey: '',
+    actionKey: '',
+    mentions: [
+      {
+        documentId: 'doc_1',
+        originKey: 'rules:x',
+        occurredAt: '2026-08-01T15:00:00Z',
+        quote: 'Status in the system reads "comments received", which is misleading.',
+        extractor: 'rules',
+      },
+    ],
+    firstSeenAt: '2026-08-01T15:00:00Z',
+    lastSeenAt: '2026-08-01T15:00:00Z',
+    extractorVersion: 'rules+model@1',
+    source: 'granola',
+    sourceLabel: 'Granola',
+    scope: SCOPE,
+    ...overrides,
+  };
+}
+
+const ROWS: Commitment[] = [
+  commitment({ externalId: 'commit:open1', title: 'Chase the inventor for comments on 2148', ownerName: 'Rae' }),
+  commitment({
+    externalId: 'commit:overdue1',
+    title: 'Send the equity sheet to Harry Holcomb',
+    dueAt: '2026-08-05T00:00:00Z',
+  }),
+  commitment({
+    externalId: 'commit:done1',
+    title: 'File the PCT for 2205',
+    status: 'done',
+    statusReason: '2205: filed as first PCT on June 25; already complete',
+    resolvedBy: 'doc_9',
+    resolvedAt: '2026-08-08T00:00:00Z',
+    lastSeenAt: '2026-08-08T00:00:00Z',
+  }),
+];
+
+function makeApi(options: {
+  rows?: Commitment[];
+  appliedFilters?: string[];
+  onQuery?: (query: CommitmentQuery) => void;
+  extract?: CommitmentTrackerApi['extract'];
+} = {}): CommitmentTrackerApi {
+  const rows = options.rows ?? ROWS;
+  return {
+    async listCommitments(query: CommitmentQuery = {}): Promise<CorpusPage<Commitment>> {
+      options.onQuery?.(query);
+      // Deliberately returns EVERYTHING, like the tenant API does today: the
+      // screen has to be correct against a server that ignores the filters.
+      return {
+        count: rows.length,
+        next: null,
+        previous: null,
+        results: rows,
+        appliedFilters: options.appliedFilters ?? [],
+      };
+    },
+    ...(options.extract ? { extract: options.extract } : {}),
+  };
+}
+
+describe('TrackerPage — what is outstanding', () => {
+  it('shows open items and hides closed ones', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+
+    expect(await screen.findByText('Chase the inventor for comments on 2148')).toBeInTheDocument();
+    expect(screen.getByText('Send the equity sheet to Harry Holcomb')).toBeInTheDocument();
+    // The one thing this screen must never do: present finished work as owed.
+    expect(screen.queryByText('File the PCT for 2205')).not.toBeInTheDocument();
+  });
+
+  it('sends the status and window as SERVER parameters', async () => {
+    const queries: CommitmentQuery[] = [];
+    render(<TrackerPage api={makeApi({ onQuery: (query) => queries.push(query) })} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+
+    expect(queries[0].status).toEqual(['open', 'blocked']);
+    expect(queries[0].pageSize).toBe(200);
+  });
+
+  it('says so when the data API does not honour the filters', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    // The Library's `appliedFilters` contract, owed here about status — a
+    // status filter that silently does nothing breaks the screen's only claim.
+    expect(
+      await screen.findByText(/does not filter by .*status/i),
+    ).toBeInTheDocument();
+  });
+
+  it('does NOT nag when the API reports it applied them', async () => {
+    render(
+      <TrackerPage
+        api={makeApi({ appliedFilters: ['status', 'owner', 'dueBefore', 'changedAfter'] })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    await screen.findByText('Chase the inventor for comments on 2148');
+    expect(screen.queryByText(/does not filter by/i)).not.toBeInTheDocument();
+  });
+
+  it('puts an overdue item above one with no due date', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+    const titles = screen.getAllByRole('article').map((node) => within(node).getByRole('heading').textContent);
+    expect(titles[0]).toBe('Send the equity sheet to Harry Holcomb');
+  });
+
+  it('says an item is overdue, with the date', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    expect(await screen.findByText(/Overdue/)).toBeInTheDocument();
+  });
+
+  it('says how long something has been open, which is the point of the screen', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    // Raised 2026-08-01, read 2026-08-10 — nine calendar days, eight elapsed.
+    expect(await screen.findAllByText(/open for 8 days/)).not.toHaveLength(0);
+  });
+
+  it('states that nobody was named rather than rendering a blank', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    // "Nobody said who owns this" is a fact about the meeting, and it is the
+    // most actionable thing on the screen. A blank cell hides it.
+    expect(await screen.findByText('No owner named')).toBeInTheDocument();
+    expect(screen.getByText('Rae')).toBeInTheDocument();
+  });
+
+  it('renders every row with the meeting it came from and a verbatim quote', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+    for (const article of screen.getAllByRole('article')) {
+      expect(within(article).getByText(/From 1 meeting/)).toBeInTheDocument();
+      expect(within(article).getByText(/Status in the system reads/)).toBeInTheDocument();
+    }
+  });
+
+  it('shows the closed tab with the sentence that closed it', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+    await userEvent.click(screen.getByRole('tab', { name: 'Closed' }));
+
+    expect(await screen.findByText('File the PCT for 2205')).toBeInTheDocument();
+    // "Why does it say this is done" has to be answerable without opening the
+    // meeting, or nobody trusts a single closed row.
+    expect(screen.getByText(/Closed by: .*filed as first PCT/)).toBeInTheDocument();
+  });
+
+  it('filters by owner', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+    await userEvent.type(screen.getByPlaceholderText('Owner'), 'Rae');
+
+    expect(screen.getByText('Chase the inventor for comments on 2148')).toBeInTheDocument();
+    expect(screen.queryByText('Send the equity sheet to Harry Holcomb')).not.toBeInTheDocument();
+  });
+
+  it('tells a fresh workspace what to do instead of showing an empty page', async () => {
+    render(<TrackerPage api={makeApi({ rows: [] })} scope={SCOPE} now={NOW} />);
+    expect(await screen.findByText(/Nothing has been pulled out of your meetings yet/)).toBeInTheDocument();
+  });
+});
+
+describe('TrackerPage — running the extraction', () => {
+  const RESULT = {
+    documentsProcessed: 16,
+    fromRules: 24,
+    fromModel: 11,
+    created: 30,
+    merged: 5,
+    resolved: 2,
+    needsReview: [{ commitmentId: 'commit:open1', documentId: 'doc_4', quote: '2148 came back from the inventor' }],
+    droppedOutOfScope: 0,
+    provider: { provider: 'anthropic', model: 'claude-sonnet-4-6', live: true },
+  };
+
+  it('reports what the run did, and what the MODEL added over the rules', async () => {
+    const extract = vi.fn(async () => RESULT);
+    render(<TrackerPage api={makeApi({ extract })} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+    await userEvent.click(screen.getByRole('button', { name: 'Pull from meetings' }));
+
+    expect(extract).toHaveBeenCalledWith({ scope: SCOPE });
+    expect(await screen.findByText(/Read 16 meetings/)).toBeInTheDocument();
+    // The measurement of whether the model call is worth paying for, on screen.
+    expect(screen.getByText(/24 came from the meetings’ own next-step lists, 11 were read/)).toBeInTheDocument();
+    expect(screen.getByText(/anthropic · claude-sonnet-4-6/)).toBeInTheDocument();
+  });
+
+  it('surfaces weak resolution matches instead of quietly closing things', async () => {
+    render(<TrackerPage api={makeApi({ extract: async () => RESULT })} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+    await userEvent.click(screen.getByRole('button', { name: 'Pull from meetings' }));
+
+    expect(await screen.findByText(/Nothing was closed automatically/)).toBeInTheDocument();
+    expect(screen.getByText(/2148 came back from the inventor/)).toBeInTheDocument();
+  });
+
+  it('reports a leaking data API rather than absorbing it', async () => {
+    render(
+      <TrackerPage
+        api={makeApi({ extract: async () => ({ ...RESULT, droppedOutOfScope: 3 }) })}
+        scope={SCOPE}
+        now={NOW}
+      />,
+    );
+    await screen.findByText('Chase the inventor for comments on 2148');
+    await userEvent.click(screen.getByRole('button', { name: 'Pull from meetings' }));
+
+    expect(await screen.findByText(/3 records from another\s+workspace were returned/)).toBeInTheDocument();
+  });
+
+  it('hides the control entirely on a read-only deployment', async () => {
+    render(<TrackerPage api={makeApi()} scope={SCOPE} now={NOW} />);
+    await screen.findByText('Chase the inventor for comments on 2148');
+    expect(screen.queryByRole('button', { name: 'Pull from meetings' })).not.toBeInTheDocument();
+  });
+});

package/src/components/index.ts

@@ -30,3 +30,4 @@ export type {
 // connections. Same rule as above — the page composers ship, not just the parts.
 export * from './pages/LibraryPage';
 export * from './pages/AskPage';
+export * from './pages/TrackerPage';