jupyterlab-codex-sidebar 0.1.4 → 0.1.6

package/src/codexChatFormatting.ts

@@ -0,0 +1,94 @@
+import type { CodexRateLimitsSnapshot } from './handlers/codexMessageTypes';
+import { coerceRateLimitsSnapshot as coerceRateLimitsSnapshotShared } from './handlers/codexMessageUtils';
+
+export function truncateMiddle(value: string, max: number): string {
+  if (value.length <= max) {
+    return value;
+  }
+  const ellipsis = '...';
+  if (max <= ellipsis.length) {
+    return value.slice(0, max);
+  }
+  const head = Math.max(0, Math.floor((max - ellipsis.length) * 0.6));
+  const tail = Math.max(0, max - head - ellipsis.length);
+  return `${value.slice(0, head)}${ellipsis}${value.slice(value.length - tail)}`;
+}
+
+export function coerceRateLimitsSnapshot(raw: any): CodexRateLimitsSnapshot | null {
+  return coerceRateLimitsSnapshotShared(raw);
+}
+
+export function clampNumber(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
+export function percentLeftFromUsed(usedPercent: number | null): number | null {
+  if (typeof usedPercent !== 'number' || !Number.isFinite(usedPercent)) {
+    return null;
+  }
+  return Math.round(clampNumber(100 - usedPercent, 0, 100));
+}
+
+export function safeParseDateMs(value: string | null): number | null {
+  if (!value) {
+    return null;
+  }
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+
+export function formatDurationShort(ms: number): string {
+  if (!Number.isFinite(ms)) {
+    return '0m';
+  }
+  const totalMinutes = Math.max(0, Math.floor(ms / 60000));
+  const days = Math.floor(totalMinutes / (60 * 24));
+  const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
+  const minutes = totalMinutes % 60;
+  if (days > 0) {
+    return `${days}d ${hours}h`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+}
+
+export function formatRunDuration(ms: number): string {
+  if (!Number.isFinite(ms)) {
+    return '0s';
+  }
+  const totalSeconds = Math.max(0, Math.round(ms / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+
+export function formatResetsIn(resetsAtSec: number | null, nowMs: number): string {
+  if (typeof resetsAtSec !== 'number' || !Number.isFinite(resetsAtSec)) {
+    return 'Unknown';
+  }
+  const diffMs = resetsAtSec * 1000 - nowMs;
+  if (diffMs <= 0) {
+    return 'Overdue';
+  }
+  return formatDurationShort(diffMs);
+}
+
+export function formatTokenCount(value: number | null): string {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return '--';
+  }
+  return value.toLocaleString();
+}
+
+export function getBrowserNotificationPermission(): NotificationPermission | 'unsupported' {
+  if (typeof window === 'undefined' || typeof window.Notification === 'undefined') {
+    return 'unsupported';
+  }
+  return window.Notification.permission;
+}
+

package/src/codexChatNotice.ts

@@ -0,0 +1,95 @@
+type SessionNoticeParseResult = {
+  rest: string;
+  value: string | null;
+};
+
+const SESSION_STARTED_EN_PATTERN = /^(?:session started|session start|new thread started)/i;
+const SESSION_STARTED_EN_COLON_PATTERN = /^(?:session start:|new thread started:)/i;
+const SESSION_STARTED_I18N_PREFIX =
+  /^(?:session|new thread|new session|thread|conversation|セッション|スレッド|チャット|会話|会議|会话|对话|대화|세션|새로운\s*세션|새\s*세션|스레드|새로운\s*스레드|새\s*스레드|sesión|conversación|conversacion|hilo|nueva sesión|nuevo hilo)/i;
+const SESSION_STARTED_I18N_SUFFIX =
+  /(?:start(?:ed|ing)?|started|start|resume|resumed|resolving|initialize(?:d|s)?|initializing|restarted|reopen|restart|시작|시작됨|시작되었습니다|起動|开始|已开始|已啟動|開始|開始しました|开始しました|已啟動しました|始ま|始動|会话开始|会議開始|会話開始|会話を開始|iniciada|iniciado|iniciar|inicio|inicio de|comenzó|comenzada|开始しました|始動|開始され|始まった)/i;
+
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function splitLeadingPhrases(value: string): boolean {
+  const leading = value.slice(0, 72);
+  return SESSION_STARTED_I18N_PREFIX.test(leading);
+}
+
+const SESSION_RESOLVED_START_VALUES = new Set([
+  'client',
+  'client-new',
+  'force-new',
+  'mapping',
+  'mapping-on-missing',
+  'mapping-on-mismatch',
+  'new',
+  'new-on-mismatch'
+]);
+
+export function isStructuredSessionStartResolution(value: unknown): boolean {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  return SESSION_RESOLVED_START_VALUES.has(value.trim().toLowerCase());
+}
+
+function extractTrailingParenValue(text: string): SessionNoticeParseResult {
+  const trimmed = text.trim();
+  if (!trimmed.endsWith(')')) {
+    return { rest: trimmed, value: null };
+  }
+  const start = trimmed.lastIndexOf('(');
+  if (start < 0) {
+    return { rest: trimmed, value: null };
+  }
+  const inner = trimmed.slice(start + 1, -1).trim();
+  if (!inner) {
+    return { rest: trimmed, value: null };
+  }
+  return { rest: trimmed.slice(0, start).trimEnd(), value: inner };
+}
+
+function formatSessionStartedNotice(label: string, time: string | null): string {
+  return `${label}${time ? ` (${time})` : ''}`;
+}
+
+export function normalizeSessionStartedNotice(text: string): string | null {
+  const raw = text.trim();
+  const { rest, value } = extractTrailingParenValue(raw);
+
+  if (SESSION_STARTED_EN_PATTERN.test(rest) || SESSION_STARTED_EN_COLON_PATTERN.test(rest)) {
+    return formatSessionStartedNotice('Session started', value);
+  }
+
+  const normalizedRest = normalizeWhitespace(rest);
+  if (SESSION_STARTED_I18N_PREFIX.test(normalizedRest) && SESSION_STARTED_I18N_SUFFIX.test(normalizedRest)) {
+    if (splitLeadingPhrases(normalizedRest) && normalizedRest.length <= 120) {
+      return `${normalizedRest}${value ? ` (${value})` : ''}`;
+    }
+  }
+
+  return null;
+}
+
+export function isSessionStartNotice(text: string, sessionResolution?: unknown): boolean {
+  if (isStructuredSessionStartResolution(sessionResolution)) {
+    return true;
+  }
+
+  const normalized = normalizeSessionStartedNotice(text);
+  if (normalized !== null) {
+    return true;
+  }
+
+  const trimmed = text.trimStart();
+  const normalizedTrimmed = normalizeWhitespace(trimmed);
+  return (
+    SESSION_STARTED_EN_COLON_PATTERN.test(normalizedTrimmed) ||
+    /^(?:new thread started|session started|session start)/i.test(normalizedTrimmed) ||
+    (SESSION_STARTED_I18N_PREFIX.test(normalizedTrimmed) && SESSION_STARTED_I18N_SUFFIX.test(normalizedTrimmed))
+  );
+}

package/src/codexChatPersistence.ts

@@ -0,0 +1,191 @@
+import {
+  hasStoredValue,
+  safeLocalStorageGet,
+  safeLocalStorageRemove,
+  safeLocalStorageSet
+} from './codexChatStorage';
+
+const SESSION_THREADS_STORAGE_KEY = 'jupyterlab-codex:session-threads';
+const SESSION_THREADS_EVENT_KEY = 'jupyterlab-codex:session-threads:event';
+const DELETE_ALL_PENDING_KEY = 'jupyterlab-codex:delete-all-pending';
+export const SESSION_KEY_SEPARATOR = '\u0000';
+
+export type SessionThreadSyncEvent = {
+  kind: 'new-thread';
+  sessionKey: string;
+  notebookPath: string;
+  threadId: string;
+  source: string;
+  id: string;
+  issuedAt: number;
+};
+
+export const STORAGE_KEY_SESSION_THREADS = SESSION_THREADS_STORAGE_KEY;
+export const STORAGE_KEY_SESSION_THREADS_EVENT = SESSION_THREADS_EVENT_KEY;
+export const STORAGE_KEY_DELETE_ALL_PENDING = DELETE_ALL_PENDING_KEY;
+
+export function parseSessionKey(sessionKey: string): { path: string } {
+  if (!sessionKey) {
+    return { path: '' };
+  }
+  const separatorIndex = sessionKey.indexOf(SESSION_KEY_SEPARATOR);
+  if (separatorIndex < 0) {
+    return { path: sessionKey };
+  }
+  return { path: sessionKey.slice(0, separatorIndex) };
+}
+
+export function readStoredSessionThreads(): Record<string, string> {
+  const raw = safeLocalStorageGet(STORAGE_KEY_SESSION_THREADS);
+  if (!raw) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') {
+      return {};
+    }
+    const result: Record<string, string> = {};
+    for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+      if (!key || typeof value !== 'string') {
+        continue;
+      }
+      const threadId = value.trim();
+      if (!threadId) {
+        continue;
+      }
+      result[key] = threadId;
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+export function getStoredSessionThreadCount(): number {
+  const mapping = readStoredSessionThreads();
+  const uniquePaths = new Set<string>();
+  for (const key of Object.keys(mapping)) {
+    const { path } = parseSessionKey(key);
+    if (path) {
+      uniquePaths.add(path);
+    }
+  }
+  return uniquePaths.size;
+}
+
+export function readStoredThreadId(path: string, sessionKey: string): string {
+  const normalizedPath = path.trim();
+  const normalizedSessionKey = sessionKey || '';
+  if (!normalizedSessionKey) {
+    return '';
+  }
+  const mapping = readStoredSessionThreads();
+  const exactMatch = mapping[normalizedSessionKey];
+  if (exactMatch) {
+    return exactMatch;
+  }
+
+  if (!normalizedPath) {
+    return '';
+  }
+  for (const [key, threadId] of Object.entries(mapping)) {
+    if (!threadId) {
+      continue;
+    }
+    const parsed = parseSessionKey(key);
+    if (parsed.path === normalizedPath) {
+      return threadId;
+    }
+  }
+  return '';
+}
+
+export function persistStoredSessionThreads(sessions: Map<string, { threadId?: string }>): void {
+  const mapping: Record<string, string> = {};
+  for (const [sessionKey, session] of sessions) {
+    if (!sessionKey || !session?.threadId) {
+      continue;
+    }
+    mapping[sessionKey] = session.threadId;
+  }
+  try {
+    safeLocalStorageSet(STORAGE_KEY_SESSION_THREADS, JSON.stringify(mapping));
+  } catch {
+    // Ignore storage failures; in-memory sessions still work.
+  }
+}
+
+export function coerceSessionThreadSyncEvent(value: string): SessionThreadSyncEvent | null {
+  if (!value) {
+    return null;
+  }
+  let raw: unknown;
+  try {
+    raw = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== 'object') {
+    return null;
+  }
+
+  const event = raw as Record<string, unknown>;
+  const sessionKey = typeof event.sessionKey === 'string' ? event.sessionKey.trim() : '';
+  const notebookPath = typeof event.notebookPath === 'string' ? event.notebookPath.trim() : '';
+  const threadId = typeof event.threadId === 'string' ? event.threadId.trim() : '';
+  const source = typeof event.source === 'string' ? event.source.trim() : '';
+  const id = typeof event.id === 'string' ? event.id.trim() : '';
+  if (!sessionKey || !notebookPath || !threadId || !id || event.kind !== 'new-thread') {
+    return null;
+  }
+  const issuedAt =
+    typeof event.issuedAt === 'number' && Number.isFinite(event.issuedAt) ? event.issuedAt : Date.now();
+  return { kind: 'new-thread', sessionKey, notebookPath, threadId, source, id, issuedAt };
+}
+
+export function buildSessionThreadSyncEvent(params: {
+  sessionKey: string;
+  notebookPath: string;
+  threadId: string;
+  source: string;
+  createEventId: () => string;
+}): SessionThreadSyncEvent {
+  const sessionKey = params.sessionKey.trim();
+  const notebookPath = params.notebookPath.trim();
+  const threadId = params.threadId.trim();
+  const source = params.source.trim();
+  return {
+    kind: 'new-thread',
+    sessionKey,
+    notebookPath,
+    threadId,
+    source,
+    id: params.createEventId(),
+    issuedAt: Date.now()
+  };
+}
+
+export function writeSessionThreadSyncEvent(payload: SessionThreadSyncEvent): void {
+  try {
+    safeLocalStorageSet(STORAGE_KEY_SESSION_THREADS_EVENT, JSON.stringify(payload));
+  } catch {
+    // Ignore sync write failures; local tab still updates immediately.
+  }
+}
+
+export function markDeleteAllPending(): void {
+  safeLocalStorageSet(STORAGE_KEY_DELETE_ALL_PENDING, '1');
+}
+
+export function clearDeleteAllPending(): void {
+  safeLocalStorageRemove(STORAGE_KEY_DELETE_ALL_PENDING);
+}
+
+export function hasDeleteAllPending(): boolean {
+  return safeLocalStorageGet(STORAGE_KEY_DELETE_ALL_PENDING) === '1';
+}
+
+export function hasStoredDeleteAllPending(): boolean {
+  return hasStoredValue(STORAGE_KEY_DELETE_ALL_PENDING);
+}