@startsimpli/integrations 0.2.11 → 0.2.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.2.11",
+  "version": "0.2.14",
   "description": "Provider-agnostic types, API clients, hooks, and UI primitives for email + calendar integrations across StartSimpli apps.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/connections.test.tsx

@@ -627,3 +627,168 @@ describe('no per-vendor components', () => {
     expect(offenders).toEqual([]);
   });
 });
+
+// --------------------------------------------------------------------------
+//  settings on a CONNECTED card (bd startsim-768w.38.31)
+// --------------------------------------------------------------------------
+//
+// A connector's `config_schema` has always shipped on every catalog row and has
+// always been rendered — but only on the CONNECT form, once, before the account
+// exists. After that there was no way to change a setting from the product at
+// all. `ReplaceKeyForm` even says so, pointing at "the connection's own
+// settings" as though that surface existed.
+//
+// It has to exist for `ingest_transcripts`, because the whole privacy posture is
+// that transcripts are off until an admin deliberately turns them on — and a
+// switch nobody can reach is not a decision anybody gets to make.
+
+/** The Granola shape: a boolean, a number and a free-text list. */
+const TRANSCRIPT_CONFIG = [
+  {
+    key: 'ingest_transcripts',
+    label: 'Store what was said, not just the summary',
+    type: 'boolean',
+    required: false,
+    default: false,
+    help: 'On: the full word-for-word transcript is stored too.',
+  },
+  {
+    key: 'transcript_retention_days',
+    label: 'Delete stored transcripts after (days)',
+    type: 'number',
+    required: false,
+    default: 90,
+  },
+];
+
+const CONFIGURABLE_CATALOG = {
+  results: [
+    {
+      ...CATALOG.results[0],
+      config_schema: { version: 1, fields: TRANSCRIPT_CONFIG },
+    },
+  ],
+};
+
+function configurableApi(overrides: Partial<ConnectionsApi> = {}): ConnectionsApi {
+  return stubApi({
+    connectorCatalog: vi.fn().mockResolvedValue(CONFIGURABLE_CATALOG),
+    connections: vi.fn().mockResolvedValue({
+      ...CONNECTED,
+      results: [{ ...CONNECTED.results[0], config: { transcript_retention_days: 90 } }],
+    }),
+    ...overrides,
+  });
+}
+
+async function openSettings(api: ConnectionsApi) {
+  render(<ConnectionsPage api={api} foundrySlug="acme" />);
+  const card = await screen.findByText('Ops n8n');
+  const section = card.closest('div[data-connection]') ?? card.parentElement!;
+  await userEvent.click(await within(section as HTMLElement).findByRole('button', { name: /Settings/i }));
+  return section as HTMLElement;
+}
+
+describe('CredentialSchemaForm — a boolean is a checkbox', () => {
+  it('renders a declared boolean as a checkbox, not a text box', () => {
+    // `bool("false")` is `True`. A privacy switch rendered as somewhere to type
+    // the word "false" is a switch that is on when the admin believes it is off.
+    renderForm(TRANSCRIPT_CONFIG);
+    const input = screen.getByLabelText(/Store what was said/i);
+    expect(input).toHaveAttribute('type', 'checkbox');
+  });
+
+  it('reports a boolean edit as a real boolean, not a string', () => {
+    const { onChange } = renderForm(TRANSCRIPT_CONFIG);
+    screen.getByLabelText(/Store what was said/i).click();
+    expect(onChange).toHaveBeenCalledWith('ingest_transcripts', true);
+  });
+
+  it('shows the declared default so an untouched field is not a guess', () => {
+    renderForm(TRANSCRIPT_CONFIG);
+    expect(screen.getByLabelText(/Store what was said/i)).not.toBeChecked();
+    expect(screen.getByLabelText(/Delete stored transcripts/i)).toHaveValue(90);
+  });
+
+  it('renders the help text, which is where the consequence is stated', () => {
+    renderForm(TRANSCRIPT_CONFIG);
+    expect(screen.getByText(/word-for-word transcript is stored/i)).toBeInTheDocument();
+  });
+});
+
+describe('ConnectionCard — a connected account has settings', () => {
+  it('renders the connector’s config schema for an existing connection', async () => {
+    const section = await openSettings(configurableApi());
+    expect(within(section).getByLabelText(/Store what was said/i)).toBeInTheDocument();
+    // The STORED value, not the declared default — a form that shows the default
+    // over a stored setting tells the admin their last change did not take.
+    expect(within(section).getByLabelText(/Delete stored transcripts/i)).toHaveValue(90);
+  });
+
+  it('does not offer settings for a connector that declares none', async () => {
+    render(<ConnectionsPage api={stubApi()} foundrySlug="acme" />);
+    const card = await screen.findByText('Ops n8n');
+    const section = (card.closest('div[data-connection]') ?? card.parentElement!) as HTMLElement;
+    expect(within(section).queryByRole('button', { name: /Settings/i })).toBeNull();
+  });
+
+  it('saves through updateConnection, sending only the fields it changed', async () => {
+    const updateConnection = vi.fn().mockResolvedValue(CONNECTED.results[0]);
+    const section = await openSettings(configurableApi({ updateConnection }));
+
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    await userEvent.click(within(section).getByRole('button', { name: /^Save settings$/i }));
+
+    await waitFor(() => expect(updateConnection).toHaveBeenCalled());
+    const [, , payload] = updateConnection.mock.calls[0];
+    expect(payload.config).toEqual({ ingest_transcripts: true });
+    // The API merges, so an untouched field must NOT be echoed back — resending
+    // it turns "I changed one thing" into "I reassert everything", and races an
+    // edit made in another tab.
+    expect(payload.config).not.toHaveProperty('transcript_retention_days');
+  });
+
+  it('sends false when a checkbox is turned OFF, rather than omitting it', async () => {
+    // The connect form drops falsy values (`if (v) config[k] = v`), which for a
+    // checkbox means "off" is indistinguishable from "untouched" — and with a
+    // merging API that makes the off position unreachable.
+    const updateConnection = vi.fn().mockResolvedValue(CONNECTED.results[0]);
+    const section = await openSettings(
+      configurableApi({
+        updateConnection,
+        connections: vi.fn().mockResolvedValue({
+          ...CONNECTED,
+          results: [{ ...CONNECTED.results[0], config: { ingest_transcripts: true } }],
+        }),
+      }),
+    );
+
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    await userEvent.click(within(section).getByRole('button', { name: /^Save settings$/i }));
+
+    await waitFor(() => expect(updateConnection).toHaveBeenCalled());
+    expect(updateConnection.mock.calls[0][2].config).toEqual({ ingest_transcripts: false });
+  });
+
+  it('warns, before saving, what turning transcripts on will do', async () => {
+    const section = await openSettings(configurableApi());
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    expect(
+      within(section).getByText(/word-for-word transcript is stored/i),
+    ).toBeInTheDocument();
+  });
+
+  it('surfaces the API’s refusal rather than looking saved', async () => {
+    // The connector refuses `transcript_retention_days: 0` with nobody's name
+    // against it. That 400 has to land on the form, next to the field.
+    const updateConnection = vi.fn().mockRejectedValue(
+      Object.assign(new Error('transcript_retention_days=0 means keeping verbatim meeting speech forever'), {
+        status: 400,
+      }),
+    );
+    const section = await openSettings(configurableApi({ updateConnection }));
+    await userEvent.click(within(section).getByLabelText(/Store what was said/i));
+    await userEvent.click(within(section).getByRole('button', { name: /^Save settings$/i }));
+    expect(await within(section).findByText(/keeping verbatim meeting speech forever/i)).toBeInTheDocument();
+  });
+});

package/src/__tests__/corpus-ask.test.ts

@@ -89,7 +89,25 @@ describe('batching — N documents, ONE call', () => {
     };
     const text = documentText(long, 500);
     expect(text.length).toBeLessThan(700);
-    expect(text).toContain('[truncated]');
+    // The marker now names the size of the cut, because "…[truncated]" told a
+    // reader that something was missing without telling them whether it was a
+    // sentence or forty minutes.
+    expect(text).toMatch(/\[truncated \d+ characters\]/);
+  });
+
+  it('spends the budget on the summary before the transcript', () => {
+    // A prefix cut over `body` + sections is what this used to be, and once
+    // `ingest_transcripts` lands `body` IS the transcript — so the entire 6,000
+    // character per-document budget would have gone on the opening minutes of
+    // the meeting and the summary would never have reached the model at all.
+    const long = {
+      ...FIXTURE_DOCUMENTS[0],
+      summary: FIXTURE_DOCUMENTS[0].summary,
+      body: `${'x'.repeat(50_000)} the last thing anybody said`,
+    };
+    const text = documentText(long, 800);
+    expect(text).toContain('Agreed to ship the connector RED suite first');
+    expect(text).toContain('the last thing anybody said');
   });
 });
 

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

@@ -106,7 +106,10 @@ describe('Markdown is rendered, not printed', () => {
 describe('LibraryPage renders a document’s own Markdown', () => {
   it('shows the summary as prose, not as source', async () => {
     const user = userEvent.setup();
-    const document: SourceDocument = { ...FIXTURE_DOCUMENTS[0], body: MARKDOWN_BODY };
+    // The SUMMARY is the field rendered as prose under the heading "Summary".
+    // It used to be `body`, which was only ever the summary because nothing had
+    // delivered a full text yet.
+    const document: SourceDocument = { ...FIXTURE_DOCUMENTS[0], summary: MARKDOWN_BODY };
     const api = createFixtureCorpusApi({ scope: SCOPE, documents: [document], moneyEvents: [] });
     render(<LibraryPage api={api} scope={SCOPE} />);
 

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

@@ -107,7 +107,7 @@ describe('LibraryPage — the only connected source is Dropbox', () => {
 });
 
 describe('LibraryPage — the same screen, Granola only', () => {
-  it('renders long-form under Granola’s word for it, from the same code', async () => {
+  it('renders the verbatim text separately from the summary, collapsed', async () => {
     const user = userEvent.setup();
     const { api } = singleSourceCorpus('granola', {
       source: 'granola', label: 'Granola', documentCount: 4,
@@ -117,7 +117,16 @@ describe('LibraryPage — the same screen, Granola only', () => {
 
     await user.click(await screen.findByText('Acme <> StartSimpli weekly sync'));
     const detail = await screen.findByRole('region', { name: 'Record detail' });
-    expect(within(detail).getByText('Transcript')).toBeInTheDocument();
+    // "Full text" and not "Transcript", because the canonical mapping puts a
+    // meeting transcript in the SAME field a PDF's extracted text goes in — the
+    // corpus is source-agnostic and this screen must stay that way. A source
+    // that wants its own word for it contributes a named `section`, which the
+    // Dropbox row above proves still works.
+    expect(within(detail).getByText('Full text')).toBeInTheDocument();
+    // The summary is still the thing rendered as prose, and the verbatim text
+    // is behind a disclosure rather than in front of whoever opened the record.
+    expect(within(detail).getByText('Summary')).toBeInTheDocument();
+    expect(within(detail).getByText(/Agreed to ship the connector RED suite/)).toBeInTheDocument();
   });
 });
 

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

@@ -247,6 +247,33 @@ describe('TrackerPage — what is outstanding', () => {
     render(<TrackerPage api={makeApi({ rows: [] })} scope={SCOPE} now={NOW} />);
     expect(await screen.findByText(/Nothing has been pulled out of your meetings yet/)).toBeInTheDocument();
   });
+
+  it('does NOT say the workspace is empty when a VIEW is empty', async () => {
+    // Browser-verified failure on the deployed tenant: the Overdue tab said
+    // "Nothing has been pulled out of your meetings yet" over ninety-seven open
+    // items, because nothing carried a due date. Advice that is false is worse
+    // than no advice.
+    const rows = [commitment({ externalId: 'commit:x', title: 'An open item' })];
+    const api: CommitmentTrackerApi = {
+      async listCommitments(query: CommitmentQuery = {}) {
+        // The server filters: the overdue query matches nothing, an unfiltered
+        // count-only probe still reports the workspace has rows.
+        const filtered = Boolean(query.dueBefore);
+        return {
+          count: filtered ? 0 : rows.length,
+          next: null, previous: null,
+          results: filtered ? [] : rows,
+          appliedFilters: ['status', 'dueBefore'],
+        };
+      },
+    };
+    render(<TrackerPage api={api} scope={SCOPE} now={NOW} />);
+    await screen.findByText('An open item');
+    await userEvent.click(screen.getByRole('tab', { name: 'Overdue' }));
+
+    expect(await screen.findByText(/Nothing matches this view/)).toBeInTheDocument();
+    expect(screen.queryByText(/Nothing has been pulled out of your meetings yet/)).not.toBeInTheDocument();
+  });
 });
 
 describe('TrackerPage — running the extraction', () => {
@@ -256,6 +283,9 @@ describe('TrackerPage — running the extraction', () => {
     nextOffset: null,
     fromRules: 24,
     fromModel: 11,
+    ungrounded: 2,
+    unconfirmed: 3,
+    verified: true,
     created: 30,
     merged: 5,
     resolved: 2,
@@ -306,3 +336,43 @@ describe('TrackerPage — running the extraction', () => {
     expect(screen.queryByRole('button', { name: 'Pull from meetings' })).not.toBeInTheDocument();
   });
 });
+
+// ---------------------------------------------------------------------------
+//  the run says what the verification threw away (bd startsim-768w.38.31)
+// ---------------------------------------------------------------------------
+
+describe('TrackerPage — the run reports its own precision work', () => {
+  const BASE = {
+    documentsProcessed: 16, totalDocuments: 16, nextOffset: null,
+    fromRules: 67, fromModel: 35, ungrounded: 2, unconfirmed: 59, verified: true,
+    created: 102, merged: 0, resolved: 0, needsReview: [], droppedOutOfScope: 0,
+    provider: { provider: 'anthropic', model: 'claude-sonnet-5', live: true },
+  };
+
+  async function runWith(result: Record<string, unknown>) {
+    const api = makeApi({ extract: vi.fn(async () => result) as never });
+    render(<TrackerPage api={api} scope={SCOPE} />);
+    await userEvent.click(await screen.findByRole('button', { name: /Pull from meetings/i }));
+    return screen;
+  }
+
+  it('says how many proposed items were dropped, and why', async () => {
+    // Measured over the sixteen real meetings, two thirds of what the model
+    // proposes does not survive the check. Hiding that would make the model look
+    // better than it is and the list less arguable than it should be.
+    await runWith(BASE);
+    expect(await screen.findByText(/61 more were proposed and dropped/)).toBeInTheDocument();
+    expect(screen.getByText(/2 quoted something the record does not say/)).toBeInTheDocument();
+    expect(screen.getByText(/59 could not be confirmed/)).toBeInTheDocument();
+  });
+
+  it('says the check did not run rather than implying it did', async () => {
+    await runWith({ ...BASE, verified: false, unconfirmed: 0, ungrounded: 0 });
+    expect(await screen.findByText(/were NOT checked against the meetings/)).toBeInTheDocument();
+  });
+
+  it('stays quiet when the model contributed nothing at all', async () => {
+    await runWith({ ...BASE, fromModel: 0, ungrounded: 0, unconfirmed: 0 });
+    expect(screen.queryByText(/proposed and dropped/)).toBeNull();
+  });
+});