@opengeni/react 1.4.4 → 1.4.5-canary.37485542607001

package/src/session-list-model.ts

@@ -0,0 +1,377 @@
+// Pure session-list presentation shared by the web app (rail and recent
+// sessions) and native renderers: relative-time labels, recency bucketing
+// (Today / Yesterday / Previous 7 days / Older), the running-first ordering
+// rule, status tones and the compact row metadata. No DOM, no React.
+import {
+  deriveAutomaticSessionTitlePreview,
+  deriveSessionDisplayTitle,
+  sessionTitleIsPending,
+  type ClientModel,
+  type Session,
+  type SessionListEntry,
+  type SessionStatus,
+} from "@opengeni/sdk";
+import { modelDisplayName } from "@opengeni/sdk/model-display";
+import { findPickerRow, type PickerModelRow } from "./model-policy";
+
+/** A list row may be a compact page entry or a complete session response. */
+export type SessionListRow = Session | SessionListEntry;
+
+/**
+ * The title shown for a session: durable agent/user metadata once available,
+ * otherwise a bounded opening-prompt preview while automatic naming is still
+ * pending. Every list, header and row reads identically.
+ */
+export function sessionDisplayTitle(session: SessionListRow): string {
+  return "displayTitle" in session ? session.displayTitle : deriveSessionDisplayTitle(session);
+}
+
+/** The maximum length a session title may be renamed to. */
+export const SESSION_TITLE_MAX_LENGTH = 200;
+
+/**
+ * The value a rename editor seeds from. A safe provisional prompt preview is
+ * editable because it is also what the user sees; the UUID-derived reference
+ * remains an empty draft rather than becoming an accidental rename.
+ */
+export function sessionRenameSeed(session: SessionListRow): string {
+  if ("renameSeed" in session) return session.renameSeed;
+  if (!sessionTitleIsPending(session)) {
+    return session.title?.trim() || "";
+  }
+  return deriveAutomaticSessionTitlePreview(session.initialMessage) ?? "";
+}
+
+/**
+ * Resolve a submitted draft against the current display title. Returns the
+ * trimmed title to persist, or `null` when the edit is a no-op (empty,
+ * unchanged from what is already shown, or still equal to the value that
+ * seeded this edit) and should simply cancel.
+ */
+export function resolveRenameSubmission(
+  draft: string,
+  display: string,
+  editSeed?: string,
+): string | null {
+  const next = draft.trim();
+  if (!next || next === display || (editSeed !== undefined && next === editSeed.trim())) {
+    return null;
+  }
+  return next;
+}
+
+export type SessionRecencyGroup = "today" | "yesterday" | "previous7" | "older";
+
+export const SESSION_GROUP_LABELS: Record<SessionRecencyGroup, string> = {
+  today: "Today",
+  yesterday: "Yesterday",
+  previous7: "Previous 7 days",
+  older: "Older",
+};
+
+/** The render order of recency groups, top → bottom. */
+export const SESSION_GROUP_ORDER: SessionRecencyGroup[] = [
+  "today",
+  "yesterday",
+  "previous7",
+  "older",
+];
+
+/** Live states that earn the pinned-to-top, breathing-dot treatment. */
+const RUNNING_STATUSES = new Set<SessionStatus>([
+  "running",
+  "queued",
+  "waiting_capacity",
+  "recovering",
+  "requires_action",
+]);
+
+export function isRunningStatus(status: SessionStatus): boolean {
+  return RUNNING_STATUSES.has(status);
+}
+
+/** An idle session waiting on its own timer, while its control is active. */
+export function sessionInputWait(
+  session: Pick<SessionListRow, "status" | "effectiveControl" | "inputWait">,
+) {
+  return session.status === "idle" && session.effectiveControl?.state === "active"
+    ? (session.inputWait ?? null)
+    : null;
+}
+
+export function hasActiveEffectiveControl(session: SessionListRow): boolean {
+  return (session.effectiveControl?.state ?? "active") === "active";
+}
+
+export function isEffectivelyRunning(session: SessionListRow): boolean {
+  // Background commands have their own chat indicator, not agent working status.
+  return (
+    hasActiveEffectiveControl(session) &&
+    (isRunningStatus(session.status) || Boolean(sessionInputWait(session)))
+  );
+}
+
+/** Most-recent activity timestamp for a session (updatedAt, then createdAt). */
+export function sessionActivityTime(session: SessionListRow): number {
+  const updated = Date.parse(session.updatedAt);
+  if (!Number.isNaN(updated)) {
+    return updated;
+  }
+  const created = Date.parse(session.createdAt);
+  return Number.isNaN(created) ? 0 : created;
+}
+
+/** Deterministic newest-first ordering for every flat or forest session list. */
+export function compareSessionActivity(left: SessionListRow, right: SessionListRow): number {
+  return sessionActivityTime(right) - sessionActivityTime(left) || right.id.localeCompare(left.id);
+}
+
+/** Deterministic personal-pin order: newest pin first, then descending id. */
+export function compareSessionPins(left: SessionListRow, right: SessionListRow): number {
+  const leftPinnedAt = Date.parse(left.pinnedAt ?? "");
+  const rightPinnedAt = Date.parse(right.pinnedAt ?? "");
+  const leftTime = Number.isNaN(leftPinnedAt) ? 0 : leftPinnedAt;
+  const rightTime = Number.isNaN(rightPinnedAt) ? 0 : rightPinnedAt;
+  return rightTime - leftTime || right.id.localeCompare(left.id);
+}
+
+/** Split explicit personal pins from ordinary rows without changing the input. */
+export function partitionPinnedSessions<T extends SessionListRow>(
+  sessions: T[],
+): {
+  pinned: T[];
+  ordinary: T[];
+} {
+  const pinned: T[] = [];
+  const ordinary: T[] = [];
+  for (const session of sessions) {
+    (session.pinned ? pinned : ordinary).push(session);
+  }
+  return { pinned: pinned.sort(compareSessionPins), ordinary };
+}
+
+/**
+ * Which recency bucket a timestamp falls into, relative to `now`. "Today" and
+ * "Yesterday" are calendar-local; "Previous 7 days" is the rest of the trailing
+ * week; everything earlier is "Older".
+ */
+export function recencyGroupFor(timestampMs: number, now: Date = new Date()): SessionRecencyGroup {
+  const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+  const startOfYesterday = startOfToday - 24 * 60 * 60 * 1000;
+  const startOfWeekWindow = startOfToday - 7 * 24 * 60 * 60 * 1000;
+  if (timestampMs >= startOfToday) {
+    return "today";
+  }
+  if (timestampMs >= startOfYesterday) {
+    return "yesterday";
+  }
+  if (timestampMs >= startOfWeekWindow) {
+    return "previous7";
+  }
+  return "older";
+}
+
+export type SessionRecencyBucket<T extends SessionListRow = SessionListRow> = {
+  group: SessionRecencyGroup;
+  label: string;
+  sessions: T[];
+};
+
+export type GroupedSessions<T extends SessionListRow = SessionListRow> = {
+  /** Running sessions, pinned above every recency group, most-recent first. */
+  running: T[];
+  /** Non-running sessions bucketed by recency (empty buckets dropped). */
+  grouped: SessionRecencyBucket<T>[];
+};
+
+/**
+ * Order + bucket the sessions for the rail. Running sessions are lifted into a
+ * synthetic, always-first position regardless of recency (rendered with a
+ * "running" marker); the remainder are bucketed by recency, most-recent first
+ * within each bucket. Empty groups are dropped.
+ */
+export function groupSessionsForRail<T extends SessionListRow>(
+  sessions: T[],
+  now: Date = new Date(),
+): GroupedSessions<T> {
+  const running = sessions.filter(isEffectivelyRunning).sort(compareSessionActivity);
+  const rest = sessions
+    .filter((session) => !isEffectivelyRunning(session))
+    .sort(compareSessionActivity);
+
+  const buckets = new Map<SessionRecencyGroup, T[]>();
+  for (const session of rest) {
+    const group = recencyGroupFor(sessionActivityTime(session), now);
+    const list = buckets.get(group) ?? [];
+    list.push(session);
+    buckets.set(group, list);
+  }
+
+  const grouped: SessionRecencyBucket<T>[] = [];
+  for (const group of SESSION_GROUP_ORDER) {
+    const list = buckets.get(group);
+    if (list && list.length > 0) {
+      grouped.push({
+        group,
+        label: SESSION_GROUP_LABELS[group],
+        sessions: list,
+      });
+    }
+  }
+  return { running, grouped };
+}
+
+export function relativeTimeLabel(value: string, now: Date = new Date()): string {
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) {
+    return "";
+  }
+  const diffSeconds = Math.max(0, Math.floor((now.getTime() - timestamp) / 1000));
+  if (diffSeconds < 45) {
+    return "now";
+  }
+  const minutes = Math.floor(diffSeconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 7) {
+    return `${days}d`;
+  }
+  return new Date(timestamp).toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+  });
+}
+
+/** Codex subscription product ids are prefixed `codex/`. */
+export function isCodexProductModel(modelId: string): boolean {
+  return modelId.startsWith("codex/");
+}
+
+export type SessionStatusTone = "queued" | "running" | "waiting" | "idle" | "failed" | "cancelled";
+
+export const SESSION_STATUS_TONE: Record<SessionStatus, SessionStatusTone> = {
+  queued: "queued",
+  running: "running",
+  recovering: "running",
+  waiting_capacity: "waiting",
+  requires_action: "waiting",
+  idle: "idle",
+  failed: "failed",
+  cancelled: "cancelled",
+};
+
+/** The status dot of a recent-session row: a background command reads as running. */
+export function recentSessionStatus(
+  session: Pick<SessionListRow, "status" | "backgroundCommandActivity">,
+): { tone: SessionStatusTone; pulse: boolean } {
+  const hasBackgroundCommand = session.backgroundCommandActivity !== undefined;
+  return {
+    tone: hasBackgroundCommand ? "running" : SESSION_STATUS_TONE[session.status],
+    pulse: hasBackgroundCommand || session.status === "running",
+  };
+}
+
+/** A short `owner/repo` label from the session's first repository resource. */
+export function sessionRepoLabel(session: Pick<Session, "resources">): string | null {
+  const repo = session.resources.find((resource) => resource.kind === "repository");
+  if (!repo || repo.kind !== "repository") {
+    return null;
+  }
+  const parts = repo.uri
+    .replace(/\.git$/, "")
+    .split("/")
+    .filter(Boolean);
+  return parts.length >= 2 ? parts.slice(-2).join("/") : (parts.at(-1) ?? null);
+}
+
+export function recentSessionModelPresentation<TCatalog extends ClientModel>(
+  modelId: string,
+  catalogRows: readonly PickerModelRow<TCatalog>[],
+): {
+  label: string;
+  billingClass: PickerModelRow["billingClass"];
+  logoUrl?: string | undefined;
+} {
+  const row = findPickerRow([...catalogRows], modelId);
+  return {
+    label: row?.label ?? modelDisplayName(modelId),
+    logoUrl: row?.catalog.logoUrl,
+    billingClass:
+      row?.billingClass ??
+      (isCodexProductModel(modelId) ? "codex_subscription" : "opengeni_credits"),
+  };
+}
+
+/**
+ * The home screen's recent sessions: server pins first, then running, then
+ * recency buckets, capped. `sessions` keeps the all-visible-row contract, so
+ * its pins are removed before recombining the explicit pinned section.
+ */
+export function recentSessionsForHome<T extends SessionListRow>(
+  sessions: T[],
+  pinned: T[],
+  limit = 6,
+  now: Date = new Date(),
+): T[] {
+  const ordinary = sessions.filter((session) => !session.pinned);
+  const { running, grouped } = groupSessionsForRail(ordinary, now);
+  return [...pinned, ...running, ...grouped.flatMap((bucket) => bucket.sessions)].slice(0, limit);
+}
+
+/** One project (workspace channel) and its sessions, as the web rail groups them. */
+export type SessionProjectSection<T extends SessionListRow = SessionListRow> = {
+  /** The channel id, or "default" for unfiled sessions. */
+  key: string;
+  channelId: string | null;
+  name: string;
+  sessions: T[];
+};
+
+/**
+ * Group top-level sessions by project in the server's project order (pinned
+ * projects first), then "Default" for unfiled ones and those whose project no
+ * longer exists. Running sessions lead each project, then the most recent.
+ * Sub-agent sessions are reached from their parent, so they are left out.
+ * Projects without sessions are kept only when `keepEmpty` is set.
+ */
+export function groupSessionsByProject<T extends SessionListRow & { channelId?: string | null }>(
+  sessions: readonly T[],
+  projects: readonly { id: string; name: string }[],
+  options: { keepEmpty?: boolean } = {},
+): SessionProjectSection<T>[] {
+  const known = new Set(projects.map((project) => project.id));
+  const byProject = new Map<string | null, T[]>();
+  for (const session of sessions) {
+    if ("parentSessionId" in session && session.parentSessionId) continue;
+    const channelId = session.channelId ?? null;
+    const key = channelId !== null && known.has(channelId) ? channelId : null;
+    byProject.set(key, [...(byProject.get(key) ?? []), session]);
+  }
+  const order = (list: T[]) =>
+    [...list].sort(
+      (left, right) =>
+        Number(isEffectivelyRunning(right)) - Number(isEffectivelyRunning(left)) ||
+        compareSessionActivity(left, right),
+    );
+  const sections: SessionProjectSection<T>[] = projects
+    .map((project) => ({
+      key: project.id,
+      channelId: project.id,
+      name: project.name,
+      sessions: order(byProject.get(project.id) ?? []),
+    }))
+    .filter((section) => options.keepEmpty || section.sessions.length > 0);
+  const unfiled = byProject.get(null) ?? [];
+  if (unfiled.length > 0) {
+    sections.push({ key: "default", channelId: null, name: "Default", sessions: order(unfiled) });
+  }
+  return sections;
+}
+
+export { findPickerRow };

package/src/session-status-model.ts

@@ -0,0 +1,62 @@
+import type { SessionStatus } from "@opengeni/sdk";
+
+/** Status token family (`--og-color-status-<tone>`) for a session status. */
+export type SessionStatusTone = "queued" | "running" | "waiting" | "idle" | "failed" | "cancelled";
+
+/** Renderer-neutral session status presentation: label, color family and liveness. */
+export const SESSION_STATUS_PRESENTATION: Record<
+  SessionStatus,
+  { label: string; tone: SessionStatusTone; pulse: boolean }
+> = {
+  queued: { label: "Queued", tone: "queued", pulse: false },
+  running: { label: "Running", tone: "running", pulse: true },
+  recovering: { label: "Recovering", tone: "running", pulse: true },
+  waiting_capacity: { label: "Waiting for capacity", tone: "waiting", pulse: true },
+  idle: { label: "Idle", tone: "idle", pulse: false },
+  requires_action: { label: "Waiting on you", tone: "waiting", pulse: true },
+  failed: { label: "Failed", tone: "failed", pulse: false },
+  cancelled: { label: "Cancelled", tone: "cancelled", pulse: false },
+};
+
+/**
+ * The status badge's color tokens (text, border and its alpha); the fill is the
+ * status color at 10%. Mirrors the web badge classes, for non-DOM renderers.
+ */
+export const SESSION_STATUS_BADGE: Record<
+  SessionStatus,
+  { text: string; border: string; borderAlpha: number; fill: string }
+> = {
+  queued: { text: "fg-muted", border: "border", borderAlpha: 1, fill: "status-queued" },
+  running: {
+    text: "status-running",
+    border: "status-running",
+    borderAlpha: 0.3,
+    fill: "status-running",
+  },
+  recovering: {
+    text: "status-running",
+    border: "status-running",
+    borderAlpha: 0.3,
+    fill: "status-running",
+  },
+  waiting_capacity: {
+    text: "status-waiting",
+    border: "status-waiting",
+    borderAlpha: 0.35,
+    fill: "status-waiting",
+  },
+  idle: { text: "status-idle", border: "status-idle", borderAlpha: 0.3, fill: "status-idle" },
+  requires_action: {
+    text: "status-waiting",
+    border: "status-waiting",
+    borderAlpha: 0.35,
+    fill: "status-waiting",
+  },
+  failed: {
+    text: "status-failed",
+    border: "status-failed",
+    borderAlpha: 0.35,
+    fill: "status-failed",
+  },
+  cancelled: { text: "fg-subtle", border: "border", borderAlpha: 1, fill: "status-cancelled" },
+};