@volter-ai-dev/supercode-ui 0.1.0

package/core.mjs

@@ -0,0 +1,349 @@
+const HARNESS_NAMES = Object.freeze({
+  'claude-code': 'Claude Code',
+  codex: 'Codex',
+  opencode: 'OpenCode',
+  pi: 'Pi',
+  grok: 'Grok',
+});
+
+export const DEFAULT_LABELS = Object.freeze({
+  chats: 'Chats',
+  newChat: 'New chat',
+  searchChats: 'Search chats',
+  askAgent: 'Ask your agent…',
+  continueHere: 'Continue here',
+  joinLive: 'Join live',
+  forkHere: 'Fork here',
+});
+
+export const EMPTY_UI_STATE = Object.freeze({
+  pill: Object.freeze({ tone: 'off', label: 'connecting…' }),
+  startup: 'connecting',
+  transcript: Object.freeze([]),
+  busy: false,
+  operation: null,
+  needsInput: false,
+  harness: '',
+  mode: 'none',
+  strategy: null,
+  canSend: false,
+  canResume: false,
+  canBranch: false,
+  canAttach: false,
+  canDetach: false,
+  canOpenTerminal: false,
+  canExport: false,
+  canReduce: false,
+  canInterrupt: false,
+  canRespond: false,
+  messaging: null,
+  workspace: '',
+  taskPlan: Object.freeze({ source: 'none', items: Object.freeze([]), residueCount: 0, observedAt: null }),
+  semantics: Object.freeze({ fidelity: null, residue: Object.freeze([]), residueCount: 0, parseErrors: 0, rawRecords: 0, subagents: Object.freeze([]) }),
+  terminalHandoff: null,
+  exportBackTarget: null,
+  exportReceipt: null,
+  reductionReceipt: null,
+  error: null,
+  recoverable: false,
+  harnesses: Object.freeze([]),
+  history: Object.freeze({ sessionLimit: 0, hasMoreSessions: false, transcriptLimit: 120, hasEarlier: false }),
+  savedDraft: '',
+  attention: Object.freeze([]),
+  sessions: Object.freeze([]),
+  attached: null,
+  owned: null,
+  attachError: null,
+});
+
+const ROLES = new Set(['system', 'user', 'assistant', 'tool', 'reasoning', 'request', 'notice']);
+const MODES = new Set(['none', 'control', 'mirror']);
+const STRATEGIES = new Set(['start', 'resume', 'attach', 'branch']);
+const STARTUP = new Set(['connecting', 'starting', 'discovering', 'ready']);
+const FIDELITY = new Set(['byte_lossless', 'value_lossless', 'semantic']);
+
+function record(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+
+function string(value, fallback = '') {
+  return typeof value === 'string' ? value : fallback;
+}
+
+function number(value, fallback = 0) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+
+function nullableNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function readTranscript(value) {
+  if (!Array.isArray(value)) return [];
+  const result = [];
+  for (const candidate of value) {
+    const item = record(candidate);
+    if (!item || typeof item.id !== 'string' || typeof item.text !== 'string' || !ROLES.has(item.role)) continue;
+    const entry = {
+      id: item.id,
+      role: item.role,
+      text: item.text,
+      ts: nullableNumber(item.ts),
+      truncated: item.truncated === true,
+    };
+    for (const key of ['label', 'arguments', 'resultText', 'code']) {
+      if (typeof item[key] === 'string') entry[key] = item[key];
+    }
+    if (['pending', 'completed', 'error'].includes(item.status)) entry.status = item.status;
+    if (typeof item.streaming === 'boolean') entry.streaming = item.streaming;
+    if (Array.isArray(item.context)) {
+      entry.context = item.context.flatMap((raw) => {
+        const context = record(raw);
+        return context && typeof context.label === 'string' && typeof context.detail === 'string'
+          ? [{
+              ...(typeof context.id === 'string' ? { id: context.id } : {}),
+              ...(typeof context.kind === 'string' ? { kind: context.kind } : {}),
+              label: context.label,
+              detail: context.detail,
+            }]
+          : [];
+      });
+    }
+    const request = record(item.request);
+    if (request && typeof request.requestKind === 'string' && typeof request.payloadText === 'string') {
+      entry.request = {
+        requestId: request.requestId,
+        requestKind: request.requestKind,
+        payloadText: request.payloadText,
+        options: Array.isArray(request.options) ? request.options.flatMap((raw) => {
+          const option = record(raw);
+          return option && typeof option.optionId === 'string' && typeof option.name === 'string'
+            ? [{ optionId: option.optionId, name: option.name, kind: string(option.kind, 'other') }]
+            : [];
+        }) : [],
+        cancellable: request.cancellable === true,
+        status: request.status === 'responded' ? 'responded' : 'pending',
+        resolution: record(request.resolution),
+      };
+    }
+    result.push(entry);
+  }
+  return result;
+}
+
+function readSessions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((raw) => {
+    const row = record(raw);
+    if (!row || typeof row.key !== 'string' || typeof row.harness !== 'string') return [];
+    return [{
+      key: row.key,
+      harness: row.harness,
+      name: string(row.name),
+      cwd: string(row.cwd),
+      title: string(row.title),
+      age: string(row.age),
+      updatedAt: nullableNumber(row.updatedAt),
+      messages: nullableNumber(row.messages),
+      active: row.active === true,
+      live: row.live === true,
+      runtimeStatus: row.runtimeStatus === 'busy' || row.runtimeStatus === 'idle' ? row.runtimeStatus : null,
+    }];
+  });
+}
+
+function readAttached(value) {
+  const item = record(value);
+  if (!item || typeof item.harness !== 'string') return null;
+  return { key: string(item.key), harness: item.harness, name: string(item.name), cwd: string(item.cwd), title: string(item.title) };
+}
+
+function readTaskPlan(value) {
+  const plan = record(value);
+  if (!plan) return { ...EMPTY_UI_STATE.taskPlan, items: [] };
+  return {
+    source: ['codex-update-plan', 'claude-tasks', 'opencode-todos'].includes(plan.source) ? plan.source : 'none',
+    items: Array.isArray(plan.items) ? plan.items.flatMap((raw) => {
+      const item = record(raw);
+      if (!item || typeof item.id !== 'string' || typeof item.title !== 'string') return [];
+      return [{
+        id: item.id,
+        title: item.title,
+        status: ['pending', 'in_progress', 'completed', 'cancelled', 'unknown'].includes(item.status) ? item.status : 'unknown',
+        ...(typeof item.nativeStatus === 'string' ? { nativeStatus: item.nativeStatus } : {}),
+        ...(Array.isArray(item.blockedBy) ? { blockedBy: item.blockedBy.filter((value) => typeof value === 'string') } : {}),
+      }];
+    }) : [],
+    residueCount: number(plan.residueCount),
+    observedAt: nullableNumber(plan.observedAt),
+  };
+}
+
+function readSemantics(value) {
+  const semantics = record(value);
+  if (!semantics) return { ...EMPTY_UI_STATE.semantics, residue: [], subagents: [] };
+  return {
+    fidelity: FIDELITY.has(semantics.fidelity) ? semantics.fidelity : null,
+    residue: Array.isArray(semantics.residue) ? semantics.residue.filter((item) => typeof item === 'string') : [],
+    residueCount: number(semantics.residueCount),
+    parseErrors: number(semantics.parseErrors),
+    rawRecords: number(semantics.rawRecords),
+    subagents: Array.isArray(semantics.subagents) ? semantics.subagents.flatMap((raw) => {
+      const child = record(raw);
+      if (!child || typeof child.id !== 'string' || typeof child.source !== 'string') return [];
+      return [{ id: child.id, source: child.source, model: typeof child.model === 'string' ? child.model : null, messages: number(child.messages), fidelity: FIDELITY.has(child.fidelity) ? child.fidelity : 'semantic' }];
+    }) : [],
+  };
+}
+
+export function normalizeUiState(value) {
+  const raw = record(value) ?? {};
+  const pill = record(raw.pill);
+  const history = record(raw.history);
+  const attachError = record(raw.attachError);
+  return {
+    pill: { tone: ['live', 'warn', 'dead'].includes(pill?.tone) ? pill.tone : 'off', label: string(pill?.label, 'connecting…') },
+    startup: STARTUP.has(raw.startup) ? raw.startup : 'connecting',
+    transcript: readTranscript(raw.transcript),
+    busy: raw.busy === true,
+    operation: typeof raw.operation === 'string' ? raw.operation : null,
+    needsInput: raw.needsInput === true,
+    harness: string(raw.harness),
+    mode: MODES.has(raw.mode) ? raw.mode : 'none',
+    strategy: STRATEGIES.has(raw.strategy) ? raw.strategy : null,
+    canSend: raw.canSend === true,
+    canResume: raw.canResume === true,
+    canBranch: raw.canBranch === true,
+    canAttach: raw.canAttach === true,
+    canDetach: raw.canDetach === true,
+    canOpenTerminal: raw.canOpenTerminal === true,
+    canExport: raw.canExport === true,
+    canReduce: raw.canReduce === true,
+    canInterrupt: raw.canInterrupt === true,
+    canRespond: raw.canRespond === true,
+    messaging: raw.messaging === 'live_peer' ? 'live_peer' : null,
+    workspace: string(raw.workspace),
+    taskPlan: readTaskPlan(raw.taskPlan),
+    semantics: readSemantics(raw.semantics),
+    terminalHandoff: record(raw.terminalHandoff),
+    exportBackTarget: typeof raw.exportBackTarget === 'string' ? raw.exportBackTarget : null,
+    exportReceipt: record(raw.exportReceipt),
+    reductionReceipt: record(raw.reductionReceipt),
+    error: typeof raw.error === 'string' ? raw.error : null,
+    recoverable: raw.recoverable === true,
+    harnesses: Array.isArray(raw.harnesses) ? raw.harnesses.flatMap((candidate) => {
+      const item = record(candidate);
+      return item && typeof item.id === 'string' ? [{ id: item.id, label: string(item.label, harnessDisplayName(item.id)), installed: item.installed === true, startable: item.startable === true, reason: typeof item.reason === 'string' ? item.reason : null }] : [];
+    }) : [],
+    history: { sessionLimit: number(history?.sessionLimit), hasMoreSessions: history?.hasMoreSessions === true, transcriptLimit: number(history?.transcriptLimit, 120), hasEarlier: history?.hasEarlier === true },
+    savedDraft: string(raw.savedDraft),
+    attention: Array.isArray(raw.attention) ? raw.attention.flatMap((candidate) => {
+      const item = record(candidate);
+      return item && typeof item.key === 'string' && ['unseen', 'finished', 'failed'].includes(item.kind)
+        ? [{ key: item.key, kind: item.kind, ...(typeof item.preview === 'string' ? { preview: item.preview } : {}) }]
+        : [];
+    }) : [],
+    sessions: readSessions(raw.sessions),
+    attached: readAttached(raw.attached),
+    owned: readAttached(raw.owned),
+    attachError: attachError && typeof attachError.key === 'string' && typeof attachError.message === 'string' ? { key: attachError.key, message: attachError.message } : null,
+  };
+}
+
+export function harnessDisplayName(id) {
+  return HARNESS_NAMES[id] ?? id;
+}
+
+export function sessionDisplayName(session) {
+  const title = session.title?.trim();
+  return title && title !== session.name ? title : session.name || 'Untitled chat';
+}
+
+export function sessionActivity(state, row) {
+  if (state.needsInput && row.active) return 'needs-input';
+  if (state.busy && row.active) return 'working';
+  const attention = state.attention.find((item) => item.key === row.key)?.kind;
+  if (attention) return attention;
+  if (row.runtimeStatus === 'busy') return 'working';
+  if (row.live || row.runtimeStatus === 'idle') return 'recent';
+  return 'idle';
+}
+
+export function filterSessions(rows, query) {
+  const needle = query.trim().toLocaleLowerCase();
+  if (!needle) return [...rows];
+  return rows.filter((row) => [row.name, row.title, row.cwd, row.harness, harnessDisplayName(row.harness)].some((value) => value.toLocaleLowerCase().includes(needle)));
+}
+
+export function groupConversation(entries) {
+  const blocks = [];
+  for (const entry of entries) {
+    if (entry.role !== 'tool') {
+      blocks.push({ kind: 'entry', id: entry.id, entry });
+      continue;
+    }
+    const previous = blocks.at(-1);
+    if (previous?.kind === 'activity') previous.entries.push(entry);
+    else blocks.push({ kind: 'activity', id: `activity:${entry.id}`, entries: [entry] });
+  }
+  return blocks;
+}
+
+export function toolCategory(entry) {
+  const name = entry.label?.toLocaleLowerCase() ?? '';
+  if (/read|view|open_file|list_dir/.test(name)) return 'read';
+  if (/search|find|grep|glob/.test(name)) return 'search';
+  if (/edit|write|patch|replace|create_file/.test(name)) return 'edit';
+  if (/test|typecheck|lint|build/.test(name)) return 'test';
+  if (/terminal|bash|shell|command|exec/.test(name)) return /\b(test|typecheck|lint|build)\b/i.test(entry.arguments ?? '') ? 'test' : 'command';
+  if (/browser|web|fetch|url/.test(name)) return 'web';
+  if (/subagent|spawn|task/.test(name)) return 'agent';
+  return 'other';
+}
+
+export function toolTarget(argumentsText) {
+  if (!argumentsText) return '';
+  try {
+    const args = JSON.parse(argumentsText);
+    for (const key of ['file_path', 'target_file', 'path', 'command', 'cmd', 'query', 'pattern', 'url']) {
+      if (typeof args?.[key] === 'string') return args[key];
+    }
+  } catch {
+    return argumentsText.length > 120 ? `${argumentsText.slice(0, 117)}…` : argumentsText;
+  }
+  return '';
+}
+
+export function compactToolTarget(target, workspace) {
+  const prefix = workspace && !workspace.endsWith('/') ? `${workspace}/` : workspace;
+  return prefix && target.startsWith(prefix) ? target.slice(prefix.length) : target;
+}
+
+export function activitySummary(entries) {
+  const counts = new Map();
+  for (const entry of entries) counts.set(toolCategory(entry), (counts.get(toolCategory(entry)) ?? 0) + 1);
+  if ([...counts.keys()].every((key) => key === 'read' || key === 'search')) return `Explored ${entries.length} ${entries.length === 1 ? 'item' : 'items'}`;
+  const labels = { edit: 'changed', test: 'tests/builds', command: 'commands', read: 'reads', search: 'searches', web: 'web', agent: 'agents', other: 'other' };
+  return `Activity · ${Object.entries(labels).flatMap(([key, label]) => counts.has(key) ? [`${counts.get(key)} ${label}`] : []).join(' · ')}`;
+}
+
+export function canContinueHere(state) {
+  if (state.mode !== 'mirror' || state.canSend) return false;
+  const row = state.attached?.key ? state.sessions.find((item) => item.key === state.attached.key) : null;
+  return state.canResume && row?.runtimeStatus !== 'busy' && row?.runtimeStatus !== 'idle';
+}
+
+export function operationLabel(operation) {
+  if (!operation) return '';
+  const labels = { discover: 'Refreshing chats…', attach: 'Opening chat…', resume: 'Continuing here…', branch: 'Starting continuation…', reduce: 'Reducing context and verifying reversibility…', terminal: 'Preparing terminal handoff…', export: 'Exporting losslessly…', refresh: 'Retrying…' };
+  return labels[operation] ?? `${operation.replaceAll('_', ' ')}…`;
+}
+
+export function terminalCommand(handoff) {
+  const quote = (value) => /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+  return [handoff.program, ...handoff.arguments].map(quote).join(' ');
+}
+
+export function isSendKey(event) {
+  return event.key === 'Enter' && !event.shiftKey && !event.isComposing;
+}