@startsimpli/integrations 0.2.24 → 0.2.26

package/src/components/pages/TrackerPage.tsx

@@ -28,6 +28,14 @@ import * as React from 'react';
 
 import { isStalled, runCoverage, runProgress } from '../../corpus/runs';
 import { stripMarkdown } from '../Markdown';
+import {
+  UnfilteredNotice,
+  WorkItemRow,
+  changedSince,
+  compareForScreen,
+  failureMessage,
+  isOverdue,
+} from './work-items';
 import type {
   Commitment,
   CommitmentQuery,
@@ -104,6 +112,9 @@ const STATUS_TABS: Array<{ key: 'open' | 'overdue' | 'recent' | 'done'; label: s
 
 const WEEK_MS = 7 * 24 * 3600 * 1000;
 
+/** Which filters THIS screen asks for, and therefore owes a confession about. */
+const TRACKER_FILTER_KEYS = ['status', 'owner', 'dueBefore', 'changedAfter'] as const;
+
 /** States the poll stops at. A finished run is a record, not a subscription. */
 const TERMINAL_RUN = new Set(['succeeded', 'failed', 'cancelled']);
 
@@ -330,10 +341,6 @@ export function TrackerPage({
   // Rendering it as "in progress" is a spinner that never ends.
   const sweepStalled = Boolean(sweep && isStalled(sweep, clock));
 
-  const unfiltered = (['status', 'owner', 'dueBefore', 'changedAfter'] as const).filter(
-    (key) => Boolean(query[key]) && !applied.includes(key),
-  );
-
   return (
     <div className={cn.root}>
       <section className={cn.section}>
@@ -418,16 +425,16 @@ export function TrackerPage({
           ) : null}
         </div>
 
-        {unfiltered.length ? (
-          // The same honesty the Library owes about search, owed here about
-          // status — and it matters more here, because "outstanding" is the
-          // claim the whole screen makes.
-          <p className={cn.warning} role="status">
-            This workspace’s data API did not filter by {unfiltered.join(', ')}, so this list was
-            narrowed in the browser over the records it could fetch. Counts are over that set, not
-            over the whole corpus.
-          </p>
-        ) : null}
+        {/* The same honesty the Library owes about search, owed here about
+            status — and it matters more here, because "outstanding" is the
+            claim the whole screen makes. Shared with the planning surface, which
+            asks for one more key. */}
+        <UnfilteredNotice
+          requested={TRACKER_FILTER_KEYS}
+          applied={applied}
+          query={query}
+          className={cn.warning}
+        />
 
         {error ? <p className={cn.error} role="alert">{error}</p> : null}
         {sweep ? (
@@ -450,7 +457,7 @@ export function TrackerPage({
         ) : null}
 
         {visible.map((item) => (
-          <CommitmentRow
+          <WorkItemRow
             key={item.externalId}
             item={item}
             now={clock}
@@ -465,94 +472,6 @@ export function TrackerPage({
 
 // ---------------------------------------------------------------------------
 
-function CommitmentRow({
-  item, now, classNames: cn, onOpenDocument,
-}: {
-  item: Commitment;
-  now: number;
-  classNames: Record<TrackerSlot, string>;
-  onOpenDocument?: (documentId: string) => void;
-}) {
-  const overdue = isOverdue(item, now);
-  const age = item.firstSeenAt ? Math.floor((now - Date.parse(item.firstSeenAt)) / 86_400_000) : null;
-
-  return (
-    <article className={cn.row}>
-      <div className="flex flex-wrap items-center gap-2">
-        <span className={cn.badge}>{item.subtype}</span>
-        {item.status !== 'open' ? <span className={cn.badge}>{item.status}</span> : null}
-        <h3 className="text-sm font-medium text-gray-900">{item.title}</h3>
-      </div>
-
-      <div className="mt-1 flex flex-wrap items-center gap-3">
-        {item.ownerName ? (
-          <span className="text-sm text-gray-700">{item.ownerName}</span>
-        ) : (
-          // Stated, not blank. "Nobody said who" is a fact about the meeting and
-          // it is the single most actionable thing on this screen.
-          <span className={cn.muted}>No owner named</span>
-        )}
-        {item.subject ? <span className={cn.muted}>· {item.subject}</span> : null}
-        {item.dueAt ? (
-          <span className={overdue ? cn.due : cn.muted}>
-            {overdue ? 'Overdue ' : 'Due '}
-            {new Date(item.dueAt).toLocaleDateString()}
-          </span>
-        ) : null}
-        {age !== null && age > 0 ? (
-          <span className={cn.muted}>
-            {/* The sentence the product exists to say. */}
-            open for {age} day{age === 1 ? '' : 's'}
-          </span>
-        ) : null}
-        {item.mentions.length > 1 ? (
-          <span className={cn.badge}>raised in {item.mentions.length} meetings</span>
-        ) : null}
-      </div>
-
-      {item.detail ? <p className="mt-2 text-sm text-gray-700">{item.detail}</p> : null}
-
-      {item.statusReason ? (
-        <p className="mt-2 text-sm text-gray-600">
-          {/* Why does it say this is closed? Answerable without opening the
-              meeting, or nobody will trust a single closed row. */}
-          {item.status === 'done' ? 'Closed by' : 'Blocked by'}: “{stripMarkdown(item.statusReason)}”
-        </p>
-      ) : null}
-
-      <details className="mt-2">
-        <summary className="cursor-pointer text-sm text-gray-600">
-          From {item.mentions.length} meeting{item.mentions.length === 1 ? '' : 's'}
-        </summary>
-        <div className="mt-2 space-y-2">
-          {item.mentions.map((mention) => (
-            <div key={`${mention.documentId}:${mention.originKey}`} className="border-t pt-2">
-              <div className="flex flex-wrap items-center gap-2">
-                <button
-                  type="button"
-                  className="text-sm text-blue-700 underline"
-                  onClick={() => onOpenDocument?.(mention.documentId)}
-                >
-                  {mention.occurredAt ? new Date(mention.occurredAt).toLocaleDateString() : 'Undated meeting'}
-                </button>
-                {/* Where the row came from. A model-derived item and one the
-                    summariser itself wrote down are different levels of
-                    evidence, and the difference belongs on screen. */}
-                <span className={cn.badge}>
-                  {mention.extractor === 'rules' ? 'from the meeting’s own next steps' : 'read from the notes'}
-                </span>
-              </div>
-              {mention.quote ? (
-                <p className="mt-1 text-sm italic text-gray-600">“{stripMarkdown(mention.quote)}”</p>
-              ) : null}
-            </div>
-          ))}
-        </div>
-      </details>
-    </article>
-  );
-}
-
 /**
  * A SWEEP IN FLIGHT, and afterwards what it did (bd startsim-768w.38.28).
  *
@@ -785,37 +704,6 @@ function RunSummary({
 
 // ---------------------------------------------------------------------------
 
-function isOverdue(item: Commitment, now: number): boolean {
-  if (!item.dueAt) return false;
-  if (item.status !== 'open' && item.status !== 'blocked') return false;
-  const at = Date.parse(item.dueAt);
-  return !Number.isNaN(at) && at < now;
-}
 
-function changedSince(item: Commitment, since: number): boolean {
-  const stamps = [item.lastSeenAt, item.resolvedAt].filter(Boolean) as string[];
-  return stamps.some((stamp) => Date.parse(stamp) >= since);
-}
 
-/**
- * Overdue first, then the oldest thing still open.
- *
- * Sorting by "raised longest ago and still not done" rather than by recency is
- * the whole difference between a list of meetings and a list of debts.
- */
-function compareForScreen(now: number) {
-  return (a: Commitment, b: Commitment): number => {
-    const overdue = Number(isOverdue(b, now)) - Number(isOverdue(a, now));
-    if (overdue !== 0) return overdue;
-    if (a.dueAt && b.dueAt && a.dueAt !== b.dueAt) return a.dueAt.localeCompare(b.dueAt);
-    if (a.dueAt !== b.dueAt) return a.dueAt ? -1 : 1;
-    return (a.firstSeenAt ?? '').localeCompare(b.firstSeenAt ?? '');
-  };
-}
 
-function failureMessage(err: unknown): string {
-  const status = (err as { status?: number })?.status;
-  if (status === 403) return 'You do not have access to this workspace’s records.';
-  if (status === 401) return 'Your session has expired. Sign in again.';
-  return (err as { message?: string })?.message || 'That could not be loaded right now.';
-}

package/src/components/pages/types.ts

@@ -47,6 +47,33 @@ export interface ConnectorSchema {
 
 export type ConnectorSchemaLike = ConnectorSchema | ConnectorFieldSpec[] | null | undefined;
 
+/**
+ * What `startOAuth`/`oauthInitiate` hand back (bd startsim-768w.22.25.22).
+ *
+ * `authorization_url` is COMPLETE — endpoint, `client_id`, `response_type`,
+ * `redirect_uri`, `state`, and whatever else the connector's own
+ * `authorization_params()` decided the vendor needs (Dropbox's includes
+ * `token_access_type=offline`, which is what makes the grant durable). The
+ * client opens it and adds nothing: it has no `client_id` of its own and must
+ * not have one to choose.
+ *
+ * `state` is opaque and signed. It is echoed by the vendor to the callback and
+ * is the only thing tying the redirect back to a connection; nothing in the
+ * browser needs to read it.
+ */
+export interface OAuthStart {
+  authorization_url: string;
+  state: string;
+  redirect_uri: string;
+}
+
+/** Vendor-side setup steps, written by the connector in Python. */
+export interface ConnectionInstructions {
+  steps?: string[];
+  headers?: Record<string, string>;
+  [key: string]: unknown;
+}
+
 export interface ConnectorCatalogEntry {
   key: string;
   name: string;
@@ -285,6 +312,22 @@ export interface ConnectionsApi {
   setMemberConnectorPolicy?(slug: string, connectorKey: string, allowed: boolean):
     Promise<{ connector_key: string; member_connect_allowed: boolean; changed: boolean }>;
 
+  /**
+   * START a consent round trip on an OAuth connector (bd startsim-768w.22.25.23).
+   *
+   * Optional so an app pinned to an older `@startsimpli/api` keeps compiling.
+   * The card branches on `auth_mode` AND on this verb being present, so a stale
+   * client renders the connector as not connectable from this screen rather
+   * than a button that cannot fire.
+   */
+  startOAuth?(slug: string, input: {
+    connector_key: string;
+    name?: string;
+    config?: Record<string, unknown>;
+    capabilities_enabled?: string[];
+    return_to?: string;
+  }): Promise<OAuthStart>;
+
   /** The roster: every member-owned connection in the foundry. Metadata only. */
   memberConnections?(slug: string): Promise<{
     results: MemberConnectionRow[];
@@ -357,4 +400,20 @@ export interface MemberConnectionsApi {
   rotateCredential(id: string, credentials: Record<string, unknown>): Promise<Connection>;
   disconnect(id: string): Promise<void>;
   connectionRuns(id: string): Promise<{ results: ConnectionRun[] }>;
+  /**
+   * The OAuth half of the surface (bd startsim-768w.22.25.14/.21). Optional so
+   * an app pinned to an older `@startsimpli/api` still type-checks; the card
+   * branches on `auth_mode` and renders the hand-off only when both the mode
+   * says oauth AND the verb is present, so a stale client degrades to saying
+   * the connector cannot be connected here rather than to a dead button.
+   */
+  startOAuth?(input: {
+    connector_key: string;
+    name?: string;
+    config?: Record<string, unknown>;
+    capabilities_enabled?: string[];
+    return_to?: string;
+  }): Promise<OAuthStart>;
+  oauthInitiate?(id: string, input?: { return_to?: string }): Promise<OAuthStart>;
+  connectionInstructions?(id: string): Promise<ConnectionInstructions>;
 }

package/src/components/pages/work-items.tsx

@@ -0,0 +1,256 @@
+/**
+ * THE PIECES TWO SCREENS SHARE — the item row, the honesty banner, and the
+ * handful of predicates that decide what "overdue" and "changed" mean
+ * (bd startsim-8l6ef).
+ *
+ * WHY THIS FILE EXISTS. `TrackerPage` and `PlanningPage` are two views over ONE
+ * list of items: the tracker asks "what came out of my meetings and is still
+ * owed", planning asks "what are we trying to achieve and what is under it".
+ * Both render the same row and both owe the same confession when the server did
+ * not honour a filter. Writing that twice is the two-lists failure moved up a
+ * level — the rows would agree while the screens slowly stopped agreeing about
+ * what they meant (CLAUDE.md rule 9, and
+ * feedback_share_page_composers_not_just_primitives).
+ *
+ * So the row and the banner live here, the extraction-run machinery stays in
+ * `TrackerPage` where it belongs, and the focus tree stays in `PlanningPage`.
+ *
+ * NOTHING HERE FETCHES. Every component takes what it renders.
+ */
+import * as React from 'react';
+
+import { isAuthored } from '../../corpus/planning';
+import { stripMarkdown } from '../Markdown';
+import type { Commitment } from '../../corpus/types';
+
+export type WorkItemSlot =
+  | 'badge' | 'muted' | 'row' | 'due' | 'warning';
+
+export const WORK_ITEM_DEFAULTS: Record<WorkItemSlot, string> = {
+  badge: 'inline-flex items-center rounded-full border border-gray-300 px-2 py-0.5 text-xs text-gray-700',
+  muted: 'text-sm text-gray-500',
+  row: 'rounded-lg border border-gray-200 p-4',
+  due: 'text-sm font-medium text-red-700',
+  warning: 'rounded-md border border-amber-300 bg-amber-50 p-3 text-sm text-amber-900',
+};
+
+const DAY_MS = 86_400_000;
+
+/** `WorkItem.Priority` — 0 critical .. 4 backlog, ascending is urgent. */
+export const PRIORITY_LABELS = ['Critical', 'High', 'Medium', 'Low', 'Backlog'] as const;
+
+export function priorityLabel(priority?: number): string | null {
+  if (priority === undefined || priority === null) return null;
+  return PRIORITY_LABELS[priority] ?? null;
+}
+
+// ---------------------------------------------------------------------------
+//  predicates — what the screens mean by "overdue" and "changed"
+// ---------------------------------------------------------------------------
+
+/**
+ * Past its stated date and still owed.
+ *
+ * A `done` or `dropped` item is never overdue however old its date is, because
+ * an overdue count is a list of things to do and a finished item is not one.
+ */
+export function isOverdue(item: Commitment, now: number): boolean {
+  if (!item.dueAt) return false;
+  if (item.status === 'done' || item.status === 'dropped') return false;
+  return Date.parse(item.dueAt) < now;
+}
+
+export function changedSince(item: Commitment, since: number): boolean {
+  const stamps = [item.lastSeenAt, item.resolvedAt].filter(Boolean) as string[];
+  return stamps.some((stamp) => Date.parse(stamp) >= since);
+}
+
+/**
+ * Overdue first, then the oldest thing still open.
+ *
+ * Sorting by "raised longest ago and still not done" rather than by recency is
+ * the whole difference between a list of meetings and a list of debts.
+ */
+export function compareForScreen(now: number) {
+  return (a: Commitment, b: Commitment): number => {
+    const overdue = Number(isOverdue(b, now)) - Number(isOverdue(a, now));
+    if (overdue !== 0) return overdue;
+    if (a.dueAt && b.dueAt && a.dueAt !== b.dueAt) return a.dueAt.localeCompare(b.dueAt);
+    if (a.dueAt !== b.dueAt) return a.dueAt ? -1 : 1;
+    return (a.firstSeenAt ?? '').localeCompare(b.firstSeenAt ?? '');
+  };
+}
+
+export function failureMessage(err: unknown): string {
+  const status = (err as { status?: number })?.status;
+  if (status === 403) return 'You do not have access to this workspace’s records.';
+  if (status === 401) return 'Your session has expired. Sign in again.';
+  return (err as { message?: string })?.message || 'That could not be loaded right now.';
+}
+
+// ---------------------------------------------------------------------------
+//  the honesty banner
+// ---------------------------------------------------------------------------
+
+/**
+ * "This workspace's data API did not filter by X."
+ *
+ * THE REQUESTED KEYS ARE A PARAMETER, and that is the change from the constant
+ * the tracker used to carry. Planning asks for `focus` as well, and a hardcoded
+ * list would have quietly excluded it from the confession — the failure being
+ * silence about silence.
+ *
+ * Note what this does NOT do: it never decides on its own whether a filter was
+ * honoured. `applied` is the SERVER's report, reconciled back into the
+ * composer's vocabulary by the client (a `focus` request comes back as
+ * `related_to`). A banner that guessed would eventually announce a gap that had
+ * been closed, which is exactly what shipped once already.
+ */
+export function UnfilteredNotice<K extends string>({
+  requested, applied, query, className,
+}: {
+  requested: readonly K[];
+  applied: readonly string[];
+  query: Partial<Record<K, unknown>>;
+  className: string;
+}) {
+  const unfiltered = requested.filter((key) => Boolean(query[key]) && !applied.includes(key));
+  if (!unfiltered.length) return null;
+  return (
+    <p className={className} role="status">
+      This workspace’s data API did not filter by {unfiltered.join(', ')}, so this list was narrowed
+      in the browser over the records it could fetch. Counts are over that set, not over the whole
+      corpus.
+    </p>
+  );
+}
+
+// ---------------------------------------------------------------------------
+//  the row
+// ---------------------------------------------------------------------------
+
+/**
+ * One item, wherever it is shown.
+ *
+ * THE AUTHORED-ITEM BRANCH IS THE POINT OF THE LIFT. This row used to state
+ * unconditionally that an item came "From N meetings" and then list them — true
+ * of everything on the screen, back when the only way to get a row was
+ * extraction. Now a person can type one, and an authored item has no mentions:
+ * rendered by the old row it read "From 0 meetings" above an empty disclosure,
+ * which says the meeting record is missing rather than that there never was one.
+ *
+ * The provenance line is therefore a fork, not a count, and both arms say
+ * something true. That difference IS the placement argument made visible: an
+ * extracted item and an authored one live in one list, and the list can still
+ * tell you which is which.
+ */
+export function WorkItemRow({
+  item, now, classNames: cn, onOpenDocument, actions,
+}: {
+  item: Commitment;
+  now: number;
+  classNames: Record<WorkItemSlot, string>;
+  onOpenDocument?: (documentId: string) => void;
+  /** Per-row controls the host screen owns (file, edit, complete). */
+  actions?: React.ReactNode;
+}) {
+  const overdue = isOverdue(item, now);
+  const age = item.firstSeenAt ? Math.floor((now - Date.parse(item.firstSeenAt)) / DAY_MS) : null;
+  const authored = isAuthored(item);
+  const priority = priorityLabel(item.priority);
+
+  return (
+    <article className={cn.row}>
+      <div className="flex flex-wrap items-center gap-2">
+        <span className={cn.badge}>{item.subtype}</span>
+        {item.status !== 'open' ? <span className={cn.badge}>{item.status}</span> : null}
+        {/* Only when set. An unset priority means nobody has triaged this, and
+            printing "Medium" would turn a missing judgement into a stated one. */}
+        {priority ? <span className={cn.badge}>{priority}</span> : null}
+        <h3 className="text-sm font-medium text-gray-900">{item.title}</h3>
+        {actions ? <span className="ml-auto flex items-center gap-2">{actions}</span> : null}
+      </div>
+
+      <div className="mt-1 flex flex-wrap items-center gap-3">
+        {item.ownerName ? (
+          <span className="text-sm text-gray-700">{item.ownerName}</span>
+        ) : (
+          // Stated, not blank. "Nobody said who" is a fact about the meeting and
+          // it is the single most actionable thing on this screen.
+          <span className={cn.muted}>No owner named</span>
+        )}
+        {item.subject ? <span className={cn.muted}>· {item.subject}</span> : null}
+        {item.dueAt ? (
+          <span className={overdue ? cn.due : cn.muted}>
+            {overdue ? 'Overdue ' : 'Due '}
+            {new Date(item.dueAt).toLocaleDateString()}
+          </span>
+        ) : null}
+        {age !== null && age > 0 ? (
+          <span className={cn.muted}>
+            {/* The sentence the product exists to say. */}
+            open for {age} day{age === 1 ? '' : 's'}
+          </span>
+        ) : null}
+        {item.mentions.length > 1 ? (
+          <span className={cn.badge}>raised in {item.mentions.length} meetings</span>
+        ) : null}
+      </div>
+
+      {item.detail ? <p className="mt-2 text-sm text-gray-700">{item.detail}</p> : null}
+
+      {item.statusReason ? (
+        <p className="mt-2 text-sm text-gray-600">
+          {/* Why does it say this is closed? Answerable without opening the
+              meeting, or nobody will trust a single closed row. */}
+          {item.status === 'done' ? 'Closed by' : 'Blocked by'}: “{stripMarkdown(item.statusReason)}”
+        </p>
+      ) : null}
+
+      {item.mentions.length === 0 ? (
+        // An authored item is its own evidence: somebody typed it, on purpose,
+        // and there is no meeting to cite. Said in one line rather than through
+        // an empty disclosure that looks like a load that failed.
+        <p className={`mt-2 ${cn.muted}`}>
+          {authored ? 'Added by hand' : 'No meeting recorded for this item'}
+        </p>
+      ) : (
+        <details className="mt-2">
+          <summary className="cursor-pointer text-sm text-gray-600">
+            From {item.mentions.length} meeting{item.mentions.length === 1 ? '' : 's'}
+          </summary>
+          <div className="mt-2 space-y-2">
+            {item.mentions.map((mention) => (
+              <div key={`${mention.documentId}:${mention.originKey}`} className="border-t pt-2">
+                <div className="flex flex-wrap items-center gap-2">
+                  <button
+                    type="button"
+                    className="text-sm text-blue-700 underline"
+                    onClick={() => onOpenDocument?.(mention.documentId)}
+                  >
+                    {mention.occurredAt
+                      ? new Date(mention.occurredAt).toLocaleDateString()
+                      : 'Undated meeting'}
+                  </button>
+                  {/* Where the row came from. A model-derived item and one the
+                      summariser itself wrote down are different levels of
+                      evidence, and the difference belongs on screen. */}
+                  <span className={cn.badge}>
+                    {mention.extractor === 'rules'
+                      ? 'from the meeting’s own next steps'
+                      : 'read from the notes'}
+                  </span>
+                </div>
+                {mention.quote ? (
+                  <p className="mt-1 text-sm italic text-gray-600">
+                    “{stripMarkdown(mention.quote)}”
+                  </p>
+                ) : null}
+              </div>
+            ))}
+          </div>
+        </details>
+      )}
+    </article>
+  );
+}