repoburg 1.3.186 → 1.3.195

package/agent-pane/frontend/src/types/index.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { runtimeIcon, formatDuration, statusToDot, statusToLabel } from './index.ts';
+
+describe('runtimeIcon', () => {
+  it('maps codex to ic-codex/CX', () => {
+    expect(runtimeIcon('codex')).toEqual({ iconClass: 'ic-codex', iconText: 'CX' });
+  });
+
+  it('maps claude to ic-claude/CL', () => {
+    expect(runtimeIcon('claude')).toEqual({ iconClass: 'ic-claude', iconText: 'CL' });
+  });
+
+  it('maps repoburg to ic-repoburg/RB', () => {
+    expect(runtimeIcon('repoburg')).toEqual({ iconClass: 'ic-repoburg', iconText: 'RB' });
+  });
+
+  it('maps cursor to ic-cursor/CR', () => {
+    expect(runtimeIcon('cursor')).toEqual({ iconClass: 'ic-cursor', iconText: 'CR' });
+  });
+
+  it('defaults to codex for unknown runtime', () => {
+    expect(runtimeIcon('unknown')).toEqual({ iconClass: 'ic-codex', iconText: 'CX' });
+  });
+});
+
+describe('formatDuration', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T00:01:00Z'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('returns seconds only for <60s', () => {
+    expect(formatDuration('2025-01-01T00:00:45Z', '2025-01-01T00:00:50Z')).toBe('5s');
+  });
+
+  it('returns 0s for same timestamps', () => {
+    expect(formatDuration('2025-01-01T00:00:00Z', '2025-01-01T00:00:00Z')).toBe('0s');
+  });
+
+  it('returns minutes and seconds for 60-3599s', () => {
+    expect(formatDuration('2025-01-01T00:00:00Z', '2025-01-01T00:03:42Z')).toBe('3m 42s');
+  });
+
+  it('returns hours and minutes for >=3600s', () => {
+    expect(formatDuration('2025-01-01T00:00:00Z', '2025-01-01T01:23:00Z')).toBe('1h 23m');
+  });
+
+  it('uses Date.now() when endISO is null', () => {
+    // start is 2025-01-01T00:00:00Z, now is 2025-01-01T00:01:00Z → 60s
+    expect(formatDuration('2025-01-01T00:00:00Z', null)).toBe('1m 0s');
+  });
+});
+
+describe('statusToDot', () => {
+  it('returns empty string when lifecycle is finished', () => {
+    expect(statusToDot('active', false, false, 'finished')).toBe('');
+  });
+
+  it('returns running when isRunning is true', () => {
+    expect(statusToDot('active', true)).toBe('running');
+  });
+
+  it('returns queued when hasUnreviewed and not failed', () => {
+    expect(statusToDot('active', false, true)).toBe('queued');
+  });
+
+  it('does not return queued when hasUnreviewed and status is failed', () => {
+    expect(statusToDot('failed', false, true)).toBe('error');
+  });
+
+  it('returns error for failed status', () => {
+    expect(statusToDot('failed', false)).toBe('error');
+  });
+
+  it('returns paused for aborted status', () => {
+    expect(statusToDot('aborted', false)).toBe('paused');
+  });
+
+  it('returns paused for active status (default)', () => {
+    expect(statusToDot('active', false)).toBe('paused');
+  });
+
+  it('returns paused for completed status', () => {
+    expect(statusToDot('completed', false)).toBe('paused');
+  });
+});
+
+describe('statusToLabel', () => {
+  it('returns Finished when lifecycle is finished', () => {
+    expect(statusToLabel('active', false, false, 'finished')).toBe('Finished');
+  });
+
+  it('returns Running when isRunning is true', () => {
+    expect(statusToLabel('active', true)).toBe('Running');
+  });
+
+  it('returns Review Pending when hasUnreviewed and not failed', () => {
+    expect(statusToLabel('active', false, true)).toBe('Review Pending');
+  });
+
+  it('returns Failed for failed status', () => {
+    expect(statusToLabel('failed', false)).toBe('Failed');
+  });
+
+  it('returns Aborted for aborted status', () => {
+    expect(statusToLabel('aborted', false)).toBe('Aborted');
+  });
+
+  it('returns Idle for active status', () => {
+    expect(statusToLabel('active', false)).toBe('Idle');
+  });
+
+  it('returns Completed for completed status', () => {
+    expect(statusToLabel('completed', false)).toBe('Completed');
+  });
+
+  it('returns Running for running status', () => {
+    expect(statusToLabel('running', false)).toBe('Running');
+  });
+
+  it('returns raw status string for unknown status', () => {
+    expect(statusToLabel('custom', false)).toBe('custom');
+  });
+});

package/agent-pane/frontend/src/types/index.ts

@@ -1,68 +1,20 @@
-// Real types matching backend schema (agent-pane/backend/src/db/schema.ts)
+// Frontend types — re-exports shared types and adds UI-only types + helper functions.
+// Shared types (Session, Turn, Item, Workspace, TokenUsage, etc.) come from @agentpane/shared.
 
-export type SessionStatus = 'active' | 'running' | 'completed' | 'failed' | 'aborted';
-export type TurnStatus = 'pending' | 'running' | 'completed' | 'failed' | 'aborted';
-export type ItemType =
-  | 'agent_message'
-  | 'reasoning'
-  | 'command_execution'
-  | 'file_change'
-  | 'mcp_tool_call'
-  | 'web_search'
-  | 'todo_list'
-  | 'error';
-export type ItemStatus = 'in_progress' | 'completed' | 'failed';
+export type {
+  SessionStatus,
+  TurnStatus,
+  ItemType,
+  ItemStatus,
+  Session,
+  Turn,
+  TokenUsage,
+  Item,
+  Workspace,
+  SessionDetail,
+} from '@agentpane/shared';
 
-export interface Session {
-  id: string;
-  title: string | null;
-  runtime_type: string;
-  model: string | null;
-  cwd: string | null;
-  external_thread_id: string | null;
-  status: SessionStatus;
-  is_running: number; // 0 | 1
-  created_at: string;
-  updated_at: string;
-}
-
-export interface TokenUsage {
-  input_tokens: number;
-  cached_input_tokens: number;
-  cache_write_input_tokens: number;
-  output_tokens: number;
-  reasoning_output_tokens: number;
-}
-
-export interface Item {
-  id: string;
-  turn_id: string;
-  external_item_id: string | null;
-  type: ItemType;
-  data: Record<string, unknown> | null;
-  status: ItemStatus;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface Turn {
-  id: string;
-  session_id: string;
-  user_prompt: string;
-  agent_response: string | null;
-  thoughts: string | null;
-  token_usage: TokenUsage | null;
-  external_turn_id: string | null;
-  status: TurnStatus;
-  error: string | null;
-  created_at: string;
-  updated_at: string;
-  items: Item[];
-}
-
-export interface SessionDetail extends Session {
-  turns: Turn[];
-}
+export type { ProviderDefinition, ProviderCapabilities, SessionRuntimeConfig, ModelInfo, Extension } from '@agentpane/shared';
 
 // UI-only types (not from backend)
 
@@ -72,13 +24,6 @@ export interface LogEntry {
   message: string;
 }
 
-export interface DiffLine {
-  type: 'add' | 'del' | 'ctx';
-  content: string;
-  oldLine?: number;
-  newLine?: number;
-}
-
 export interface PaletteCommand {
   id: string;
   label: string;
@@ -89,27 +34,96 @@ export interface PaletteCommand {
 export type RightTab = 'turns' | 'metrics' | 'changes' | 'logs';
 export type ChangesScope = 'session' | 'turngroup';
 
-// Helper: map SessionStatus to UI status dot class
-export function statusToDot(status: SessionStatus, isRunning: boolean): string {
+/**
+ * Map a runtime type string to an icon class and text badge for the UI.
+ * @param runtimeType — The session's `runtime_type` field (e.g. `'codex'`, `'claude'`).
+ * @returns An object with `iconClass` (CSS class) and `iconText` (2-letter badge).
+ */
+export function runtimeIcon(runtimeType: string): { iconClass: string; iconText: string } {
+  switch (runtimeType) {
+    case 'claude':
+      return { iconClass: 'ic-claude', iconText: 'CL' };
+    case 'codex':
+      return { iconClass: 'ic-codex', iconText: 'CX' };
+    case 'repoburg':
+      return { iconClass: 'ic-repoburg', iconText: 'RB' };
+    case 'cursor':
+      return { iconClass: 'ic-cursor', iconText: 'CR' };
+    default:
+      return { iconClass: 'ic-codex', iconText: 'CX' };
+  }
+}
+
+/**
+ * Format a duration between two ISO timestamps as a human-readable string.
+ * @param startISO — Start timestamp in ISO 8601 format.
+ * @param endISO — End timestamp in ISO 8601 format, or `null` to use `Date.now()` (for running sessions).
+ * @returns Duration string like `'12s'`, `'3m 42s'`, or `'1h 23m'`.
+ */
+export function formatDuration(startISO: string, endISO: string | null): string {
+  const start = new Date(startISO).getTime();
+  const end = endISO ? new Date(endISO).getTime() : Date.now();
+  const seconds = Math.max(0, Math.floor((end - start) / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remSec = seconds % 60;
+  if (minutes < 60) return `${minutes}m ${remSec}s`;
+  const hours = Math.floor(minutes / 60);
+  const remMin = minutes % 60;
+  return `${hours}h ${remMin}m`;
+}
+
+/**
+ * Map a session's state to a CSS status-dot class for the sidebar/tabs.
+ * @param status — The session's `status` field from the DB.
+ * @param isRunning — Whether the session is currently running a turn.
+ * @param hasUnreviewed — Whether the session has unreviewed completed turns.
+ * @param lifecycle — The session's lifecycle (`'working'` or `'finished'`).
+ * @returns A dot class string (`'running'`, `'queued'`, `'error'`, `'paused'`) or `''` (no dot).
+ */
+export function statusToDot(status: string, isRunning: boolean, hasUnreviewed = false, lifecycle = 'working'): string {
+  if (lifecycle === 'finished') return '';
   if (isRunning) return 'running';
+  if (hasUnreviewed && status !== 'failed') return 'queued';
   switch (status) {
-    case 'active': return 'done';
-    case 'completed': return 'done';
-    case 'failed': return 'error';
-    case 'aborted': return 'paused';
-    default: return 'done';
+    case 'failed':
+      return 'error';
+    case 'aborted':
+      return 'paused';
+    default:
+      return 'paused';
   }
 }
 
-// Helper: map SessionStatus to UI status label
-export function statusToLabel(status: SessionStatus, isRunning: boolean): string {
+/**
+ * Map a session's state to a human-readable status label for the UI.
+ * @param status — The session's `status` field from the DB.
+ * @param isRunning — Whether the session is currently running a turn.
+ * @param hasUnreviewed — Whether the session has unreviewed completed turns.
+ * @param lifecycle — The session's lifecycle (`'working'` or `'finished'`).
+ * @returns A label string like `'Running'`, `'Review Pending'`, `'Idle'`, `'Finished'`, `'Failed'`.
+ */
+export function statusToLabel(
+  status: string,
+  isRunning: boolean,
+  hasUnreviewed = false,
+  lifecycle = 'working',
+): string {
+  if (lifecycle === 'finished') return 'Finished';
   if (isRunning) return 'Running';
+  if (hasUnreviewed && status !== 'failed') return 'Review Pending';
   switch (status) {
-    case 'active': return 'Active';
-    case 'completed': return 'Completed';
-    case 'running': return 'Running';
-    case 'failed': return 'Failed';
-    case 'aborted': return 'Aborted';
-    default: return status;
+    case 'failed':
+      return 'Failed';
+    case 'aborted':
+      return 'Aborted';
+    case 'active':
+      return 'Idle';
+    case 'completed':
+      return 'Completed';
+    case 'running':
+      return 'Running';
+    default:
+      return status;
   }
-}
+}

package/agent-pane/frontend/src/utils/changes.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { collectFileChanges } from './changes.ts';
+import type { Turn } from '@agentpane/shared';
+
+function makeTurn(items: { type: string; data?: Record<string, unknown> }[]): Turn {
+  return {
+    id: 't1',
+    session_id: 's1',
+    user_prompt: 'test',
+    agent_response: null,
+    thoughts: null,
+    token_usage: null,
+    external_turn_id: null,
+    status: 'completed',
+    error: null,
+    created_at: '2025-01-01T00:00:00Z',
+    updated_at: '2025-01-01T00:00:00Z',
+    items: items.map((item, i) => ({
+      id: `i${i}`,
+      turn_id: 't1',
+      external_item_id: `ext${i}`,
+      type: item.type,
+      data: item.data ?? null,
+      status: 'completed',
+      created_at: '2025-01-01T00:00:00Z',
+      updated_at: '2025-01-01T00:00:00Z',
+    })),
+  } as Turn;
+}
+
+describe('collectFileChanges', () => {
+  it('returns empty array for empty turns', () => {
+    expect(collectFileChanges([])).toEqual([]);
+  });
+
+  it('returns empty array when no file_change items', () => {
+    const turn = makeTurn([{ type: 'agent_message', data: { text: 'hello' } }]);
+    expect(collectFileChanges([turn])).toEqual([]);
+  });
+
+  it('collects file changes from all turns in session scope', () => {
+    const t1 = makeTurn([{ type: 'file_change', data: { changes: [{ path: '/src/a.ts', kind: 'modify' }] } }]);
+    const t2 = makeTurn([{ type: 'file_change', data: { changes: [{ path: '/src/b.ts', kind: 'create' }] } }]);
+    const result = collectFileChanges([t1, t2]);
+    expect(result).toHaveLength(2);
+    expect(result[0].path).toBe('/src/a.ts');
+    expect(result[1].path).toBe('/src/b.ts');
+  });
+
+  it('collects from single turn in turngroup scope', () => {
+    const t1 = makeTurn([{ type: 'file_change', data: { changes: [{ path: '/src/a.ts', kind: 'modify' }] } }]);
+    const t2 = makeTurn([{ type: 'file_change', data: { changes: [{ path: '/src/b.ts', kind: 'create' }] } }]);
+    const result = collectFileChanges([t1, t2], 'turngroup', 0);
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe('/src/a.ts');
+  });
+
+  it('deduplicates by path keeping last occurrence', () => {
+    const t1 = makeTurn([{ type: 'file_change', data: { changes: [{ path: '/src/a.ts', kind: 'modify' }] } }]);
+    const t2 = makeTurn([{ type: 'file_change', data: { changes: [{ path: '/src/a.ts', kind: 'delete' }] } }]);
+    const result = collectFileChanges([t1, t2]);
+    expect(result).toHaveLength(1);
+    expect(result[0].kind).toBe('delete');
+  });
+
+  it('handles multiple changes in a single item', () => {
+    const turn = makeTurn([
+      {
+        type: 'file_change',
+        data: {
+          changes: [
+            { path: '/src/a.ts', kind: 'modify' },
+            { path: '/src/b.ts', kind: 'create' },
+          ],
+        },
+      },
+    ]);
+    const result = collectFileChanges([turn]);
+    expect(result).toHaveLength(2);
+  });
+});

package/agent-pane/frontend/src/utils/changes.ts

@@ -0,0 +1,39 @@
+import type { Turn, ChangesScope } from '../types/index.ts';
+
+export interface FileChangeEntry {
+  path: string;
+  kind: string;
+  turnIdx: number;
+}
+
+/** Collect file changes from turns, optionally scoped to a single turn.
+ *  Deduplicates by path (keeps last occurrence).
+ *  @param turns  All turns in the session.
+ *  @param scope  'session' = all turns, 'turngroup' = only `turnIdx`.
+ *  @param turnIdx  Index of the selected turn (used when scope = 'turngroup').
+ *  @returns Deduplicated list of file changes. */
+export function collectFileChanges(turns: Turn[], scope: ChangesScope = 'session', turnIdx = 0): FileChangeEntry[] {
+  const entries: FileChangeEntry[] = [];
+
+  if (scope === 'session') {
+    turns.forEach((t, ti) => extractChanges(t, ti, entries));
+  } else {
+    const turn = turns[turnIdx];
+    if (turn) extractChanges(turn, turnIdx, entries);
+  }
+
+  // Deduplicate by path (keep last occurrence)
+  const seen = new Map<string, FileChangeEntry>();
+  for (const e of entries) seen.set(e.path, e);
+  return Array.from(seen.values());
+}
+
+/** Extract file_change items from a single turn into the entries array. */
+function extractChanges(turn: Turn, turnIdx: number, entries: FileChangeEntry[]): void {
+  for (const item of turn.items) {
+    if (item.type === 'file_change' && item.data?.changes) {
+      const changes = item.data.changes as Array<{ path: string; kind: string }>;
+      for (const c of changes) entries.push({ path: c.path, kind: c.kind, turnIdx });
+    }
+  }
+}

package/agent-pane/frontend/src/utils/duration.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { calcSessionDuration } from './duration.ts';
+import type { SessionDetail } from '@agentpane/shared';
+
+function makeDetail(turns: { created_at: string; updated_at: string }[]): SessionDetail {
+  return {
+    id: 's1',
+    title: null,
+    runtime_type: 'codex',
+    model: null,
+    model_reasoning_effort: null,
+    cwd: null,
+    external_thread_id: null,
+    status: 'active',
+    is_running: 0,
+    lifecycle: 'working',
+    has_unreviewed: 0,
+    runtime_config: null,
+    created_at: '2025-01-01T00:00:00Z',
+    updated_at: '2025-01-01T00:00:00Z',
+    turns: turns.map((t, i) => ({
+      id: `t${i}`,
+      session_id: 's1',
+      user_prompt: 'test',
+      agent_response: null,
+      thoughts: null,
+      token_usage: null,
+      external_turn_id: null,
+      status: 'completed',
+      error: null,
+      created_at: t.created_at,
+      updated_at: t.updated_at,
+      items: [],
+    })),
+  } as SessionDetail;
+}
+
+describe('calcSessionDuration', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T01:00:00Z'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('returns — for null detail', () => {
+    expect(calcSessionDuration(null, false)).toBe('—');
+  });
+
+  it('returns — for empty turns', () => {
+    const detail = makeDetail([]);
+    expect(calcSessionDuration(detail, false)).toBe('—');
+  });
+
+  it('uses lastTurn.updated_at when not running', () => {
+    const detail = makeDetail([
+      { created_at: '2025-01-01T00:00:00Z', updated_at: '2025-01-01T00:00:00Z' },
+      { created_at: '2025-01-01T00:00:10Z', updated_at: '2025-01-01T00:05:00Z' },
+    ]);
+    // 5 minutes = 300s = 5m 0s
+    expect(calcSessionDuration(detail, false)).toBe('5m 0s');
+  });
+
+  it('uses Date.now() when running (null endISO)', () => {
+    const detail = makeDetail([{ created_at: '2025-01-01T00:00:00Z', updated_at: '2025-01-01T00:00:30Z' }]);
+    // now is 01:00:00, start is 00:00:00 → 3600s = 1h 0m
+    expect(calcSessionDuration(detail, true)).toBe('1h 0m');
+  });
+});

package/agent-pane/frontend/src/utils/duration.ts

@@ -0,0 +1,14 @@
+import type { SessionDetail } from '../types/index.ts';
+import { formatDuration } from '../types/index.ts';
+
+/** Calculate the total duration of a session from first turn to last turn (or now if running).
+ *  @param detail  SessionDetail with turns.
+ *  @param isRunning  Whether the session is currently running (extends to now).
+ *  @returns Formatted duration string, or '—' if no turns. */
+export function calcSessionDuration(detail: SessionDetail | null, isRunning: boolean): string {
+  if (!detail || detail.turns.length === 0) return '—';
+  const firstTurn = detail.turns[0];
+  const lastTurn = detail.turns[detail.turns.length - 1];
+  const endISO = isRunning ? null : lastTurn.updated_at;
+  return formatDuration(firstTurn.created_at, endISO);
+}

package/agent-pane/frontend/tsconfig.json

@@ -15,7 +15,10 @@
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true,
-    "allowImportingTsExtensions": true
+    "allowImportingTsExtensions": true,
+    "paths": {
+      "@agentpane/shared": ["../shared/types.ts"]
+    }
   },
   "include": ["src"],
   "exclude": ["node_modules"]

package/agent-pane/frontend/vite.config.ts

@@ -1,8 +1,14 @@
 import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
+import { resolve } from 'node:path';
 
 export default defineConfig({
   plugins: [react()],
+  resolve: {
+    alias: {
+      '@agentpane/shared': resolve(__dirname, '../shared/types.ts'),
+    },
+  },
   server: {
     port: 5174,
     proxy: {

package/agent-pane/frontend/vitest.config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+import { resolve } from 'node:path';
+
+/**
+ * Frontend vitest configuration.
+ *
+ * RAM mitigation: single-fork mode + no file parallelism.
+ * Runs all test files in one Node.js process, one file at a time.
+ */
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@agentpane/shared': resolve(__dirname, '../shared/types.ts'),
+    },
+  },
+  test: {
+    environment: 'jsdom',
+    setupFiles: ['./src/test-setup.ts'],
+    // RAM: single process, one file at a time
+    pool: 'forks',
+    poolOptions: {
+      forks: { singleFork: true },
+    },
+    fileParallelism: false,
+    maxConcurrency: 1,
+  },
+});