@startsimpli/integrations 0.1.5 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "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",
@@ -48,7 +48,7 @@
     "react-dom": "^19.0.0",
     "typescript": "^6.0.0",
     "vitest": "^3.0.0",
-    "@startsimpli/llm": "0.4.14"
+    "@startsimpli/llm": "0.4.15"
   },
   "scripts": {
     "type-check": "tsc --noEmit",

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

@@ -0,0 +1,196 @@
+/**
+ * What the corpus surfaces SAY, as opposed to what they fetch.
+ *
+ * Three defects the pre-demo rehearsal (bd startsim-768w.38.10) put on a
+ * screenshot, all of them the kind that survives a green test suite because no
+ * assertion ever read the sentence:
+ *
+ *   • Markdown rendered literally — `## Decisions` and `**$4,800**` as text
+ *     (bd startsim-768w.38.10, MINOR);
+ *   • `Answered by a none stub ((provider default))` — not English, and
+ *     `(provider default)` where the model's name belongs
+ *     (bd startsim-768w.38.21);
+ *   • `1 more record were searched`.
+ */
+import { describe, expect, it } from 'vitest';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { Markdown, stripMarkdown } from '../components/Markdown';
+import { AskPage } from '../components/pages/AskPage';
+import { LibraryPage } from '../components/pages/LibraryPage';
+import { configuredModel } from '../corpus/llm';
+import { createFixtureCorpusApi, FIXTURE_DOCUMENTS, FIXTURE_ORG } from '../corpus/fixtures';
+import type { AskResult, CorpusAskApi, SourceDocument } from '../corpus/types';
+
+const SCOPE = { orgId: FIXTURE_ORG };
+
+const MARKDOWN_BODY = [
+  '## Decisions',
+  '- Globex pricing agreed at **$4,800 per month**, 20 seats included.',
+  '- Additional seats are `$95` each per month.',
+  '',
+  'See the [rate card](https://docs.example/rate-card) for the rest.',
+].join('\n');
+
+function resultWith(overrides: Partial<AskResult>): AskResult {
+  const document = FIXTURE_DOCUMENTS[0];
+  return {
+    status: 'answered',
+    answer: MARKDOWN_BODY,
+    citations: [{ documentId: document.id, document, quote: '**SAML SSO has not shipped**' }],
+    considered: [{ document, score: 1, matchedTerms: ['globex'], snippet: '' }],
+    unresolvedCitations: [],
+    droppedOutOfScope: 0,
+    provider: { provider: 'openai', model: 'gpt-4o-mini', live: true },
+    ...overrides,
+  };
+}
+
+function askApi(result: AskResult): CorpusAskApi {
+  return { ask: async () => result };
+}
+
+async function ask(result: AskResult) {
+  const user = userEvent.setup();
+  render(<AskPage api={askApi(result)} scope={SCOPE} />);
+  await user.type(screen.getByRole('textbox'), 'What did we agree?');
+  await user.click(screen.getByRole('button', { name: 'Ask' }));
+  return screen.findByRole('region', { name: 'Answer' });
+}
+
+// ---------------------------------------------------------------------------
+
+describe('Markdown is rendered, not printed', () => {
+  it('turns a heading into a heading rather than two hashes', () => {
+    render(<Markdown text={MARKDOWN_BODY} />);
+    expect(screen.getByText('Decisions')).toBeInTheDocument();
+    expect(screen.queryByText(/##/)).not.toBeInTheDocument();
+  });
+
+  it('emphasises an amount instead of wrapping it in asterisks', () => {
+    render(<Markdown text={MARKDOWN_BODY} />);
+    const strong = screen.getByText('$4,800 per month');
+    expect(strong.tagName).toBe('STRONG');
+    expect(screen.queryByText(/\*\*/)).not.toBeInTheDocument();
+  });
+
+  it('makes a list a list, and a link a link', () => {
+    render(<Markdown text={MARKDOWN_BODY} />);
+    expect(screen.getAllByRole('listitem')).toHaveLength(2);
+    expect(screen.getByRole('link', { name: 'rate card' })).toHaveAttribute(
+      'href',
+      'https://docs.example/rate-card',
+    );
+  });
+
+  it('keeps the label but drops the link for a scheme it does not trust', () => {
+    render(<Markdown text={'[click me](javascript:doSomething)'} />);
+    expect(screen.getByText('click me')).toBeInTheDocument();
+    expect(screen.queryByRole('link')).not.toBeInTheDocument();
+  });
+
+  it('leaves prose containing a lone asterisk exactly as written', () => {
+    // A false positive here silently edits somebody's contract.
+    render(<Markdown text={'Fees are 2.5% * the invoice total.'} />);
+    expect(screen.getByText('Fees are 2.5% * the invoice total.')).toBeInTheDocument();
+  });
+
+  it('flattens to plain text when a string is what is needed', () => {
+    expect(stripMarkdown('## Blocker\n- **SAML SSO** has not shipped')).toBe(
+      'Blocker\nSAML SSO has not shipped',
+    );
+  });
+});
+
+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 };
+    const api = createFixtureCorpusApi({ scope: SCOPE, documents: [document], moneyEvents: [] });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    await user.click(await screen.findByText(document.title));
+    const detail = await screen.findByRole('region', { name: 'Record detail' });
+    expect(within(detail).getByText('Decisions')).toBeInTheDocument();
+    expect(within(detail).getByText('$4,800 per month').tagName).toBe('STRONG');
+  });
+});
+
+describe('AskPage says who answered, in English', () => {
+  it('names the model when one answered', async () => {
+    const panel = await ask(resultWith({}));
+    expect(within(panel).getByText('Answered by openai · gpt-4o-mini')).toBeInTheDocument();
+  });
+
+  it('says no model is configured rather than "a none stub ((provider default))"', async () => {
+    const panel = await ask(
+      resultWith({ provider: { provider: 'none', model: '', live: false } }),
+    );
+    expect(within(panel).getByText(/No model is configured for this workspace/)).toBeInTheDocument();
+    // The honesty is kept: it still says nothing live ran.
+    expect(within(panel).getByText(/no live model was called/)).toBeInTheDocument();
+    expect(within(panel).queryByText(/\(\(/)).not.toBeInTheDocument();
+    expect(within(panel).queryByText(/none stub/)).not.toBeInTheDocument();
+  });
+
+  it('still calls a stub a stub', async () => {
+    const panel = await ask(
+      resultWith({ provider: { provider: 'fixture', model: 'fixture-echo', live: false } }),
+    );
+    expect(
+      within(panel).getByText('Answered by a fixture stub (fixture-echo) — no live model was called'),
+    ).toBeInTheDocument();
+  });
+
+  it('renders the answer’s Markdown and flattens the citation quote', async () => {
+    const panel = await ask(resultWith({}));
+    expect(within(panel).getByText('Decisions')).toBeInTheDocument();
+    expect(within(panel).getByText('“SAML SSO has not shipped”')).toBeInTheDocument();
+  });
+
+  it('agrees in number about how many records went uncited', async () => {
+    const document = FIXTURE_DOCUMENTS[1];
+    const panel = await ask(
+      resultWith({
+        considered: [
+          { document: FIXTURE_DOCUMENTS[0], score: 1, matchedTerms: [], snippet: '' },
+          { document, score: 0.5, matchedTerms: [], snippet: '' },
+        ],
+      }),
+    );
+    expect(within(panel).getByText('1 more record was searched but not cited')).toBeInTheDocument();
+  });
+
+  it('uses the plural when more than one was passed over', async () => {
+    const panel = await ask(
+      resultWith({
+        considered: [
+          { document: FIXTURE_DOCUMENTS[0], score: 1, matchedTerms: [], snippet: '' },
+          { document: FIXTURE_DOCUMENTS[1], score: 0.5, matchedTerms: [], snippet: '' },
+          { document: FIXTURE_DOCUMENTS[2], score: 0.4, matchedTerms: [], snippet: '' },
+        ],
+      }),
+    );
+    expect(within(panel).getByText('2 more records were searched but not cited')).toBeInTheDocument();
+  });
+});
+
+describe('the model named before the first call is the CONFIGURED one', () => {
+  it('reads the provider’s own variable', () => {
+    expect(configuredModel('openai', { OPENAI_MODEL: 'gpt-4o-mini' })).toBe('gpt-4o-mini');
+    expect(configuredModel('anthropic', { ANTHROPIC_MODEL: 'claude-x' })).toBe('claude-x');
+  });
+
+  it('prefers the specific variable over the generic one', () => {
+    expect(configuredModel('openai', { OPENAI_MODEL: 'gpt-4o-mini', LLM_MODEL: 'other' })).toBe(
+      'gpt-4o-mini',
+    );
+  });
+
+  it('falls back to LLM_MODEL, and to nothing at all', () => {
+    expect(configuredModel('openai', { LLM_MODEL: 'gpt-5' })).toBe('gpt-5');
+    expect(configuredModel('openai', {})).toBe('');
+    expect(configuredModel('none', { OPENAI_MODEL: 'gpt-4o-mini' })).toBe('');
+  });
+});