@vibelet/cli 0.1.35 → 0.1.37

package/src/session-inventory.perf.test.ts

@@ -0,0 +1,250 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import type { SessionInfo } from '@vibelet/shared';
+import { buildSessionInventoryPage, type InventorySources, type ActiveSessionSnapshot, type SessionRecord } from './session-inventory.js';
+import type { RunningSessionCandidate } from './process-scanner.js';
+
+function makeSessionInfo(index: number, state: 'idle' | 'externalRunning' = 'idle'): SessionInfo {
+  const ts = new Date(Date.now() - index * 60_000).toISOString();
+  return {
+    sessionId: `session-${index}`,
+    agent: index % 2 === 0 ? 'claude' : 'codex',
+    cwd: `/repo/project-${index % 10}`,
+    title: `Session title ${index} - doing something ${index % 5 === 0 ? 'important' : 'routine'}`,
+    createdAt: ts,
+    lastActivityAt: ts,
+    sources: ['scanner'],
+    runtime: {
+      state,
+      confidence: 'high',
+      resumeMode: 'resumeSession',
+    },
+  };
+}
+
+function makeActiveSnapshot(index: number): ActiveSessionSnapshot {
+  const ts = new Date(Date.now() - index * 30_000).toISOString();
+  return {
+    sessionId: `active-${index}`,
+    agent: index % 2 === 0 ? 'claude' : 'codex',
+    cwd: `/repo/project-${index % 5}`,
+    title: `Active session ${index}`,
+    createdAt: ts,
+    lastActivityAt: ts,
+  };
+}
+
+function makeSessionRecord(index: number): SessionRecord {
+  const ts = new Date(Date.now() - index * 120_000).toISOString();
+  return {
+    sessionId: `record-${index}`,
+    agent: index % 2 === 0 ? 'claude' : 'codex',
+    cwd: `/repo/project-${index % 8}`,
+    title: `Record session ${index}`,
+    createdAt: ts,
+    lastActivityAt: ts,
+  };
+}
+
+function makeRunningCandidate(index: number): RunningSessionCandidate {
+  return {
+    agent: index % 2 === 0 ? 'claude' : 'codex',
+    pid: 10000 + index,
+    cwd: `/repo/project-${index % 6}`,
+    command: `${index % 2 === 0 ? 'claude' : 'codex'} --resume session-running-${index}`,
+    sessionId: `running-${index}`,
+    confidence: index % 3 === 0 ? 'high' : 'medium',
+  };
+}
+
+function makeSources(counts: {
+  scanned?: number;
+  active?: number;
+  records?: number;
+  running?: number;
+}): InventorySources {
+  return {
+    scannedSessions: Array.from({ length: counts.scanned ?? 0 }, (_, i) => makeSessionInfo(i)),
+    activeSessions: Array.from({ length: counts.active ?? 0 }, (_, i) => makeActiveSnapshot(i)),
+    sessionRecords: Array.from({ length: counts.records ?? 0 }, (_, i) => makeSessionRecord(i)),
+    runningSessions: Array.from({ length: counts.running ?? 0 }, (_, i) => makeRunningCandidate(i)),
+    scannedAt: new Date().toISOString(),
+  };
+}
+
+function measure(fn: () => void, iterations: number): { totalMs: number; avgMs: number } {
+  // warmup
+  fn();
+  const start = performance.now();
+  for (let i = 0; i < iterations; i++) fn();
+  const totalMs = performance.now() - start;
+  return { totalMs, avgMs: totalMs / iterations };
+}
+
+describe('session-inventory performance', () => {
+
+  describe('buildSessionInventoryPage - merge + sort + paginate', () => {
+
+    it('100 scanned sessions × 100 iterations < 100ms', () => {
+      const src = makeSources({ scanned: 100 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50);
+      }, 100);
+      console.log(`  100 scanned: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
+    });
+
+    it('500 scanned sessions × 50 iterations < 200ms', () => {
+      const src = makeSources({ scanned: 500 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50);
+      }, 50);
+      console.log(`  500 scanned: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+
+    it('1000 scanned sessions × 20 iterations < 300ms', () => {
+      const src = makeSources({ scanned: 1000 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50);
+      }, 20);
+      console.log(`  1000 scanned: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 300, `took ${totalMs.toFixed(2)}ms, expected < 300ms`);
+    });
+
+    it('2000 scanned sessions × 10 iterations < 500ms', () => {
+      const src = makeSources({ scanned: 2000 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50);
+      }, 10);
+      console.log(`  2000 scanned: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 500, `took ${totalMs.toFixed(2)}ms, expected < 500ms`);
+    });
+  });
+
+  describe('buildSessionInventoryPage - multi-source merge', () => {
+
+    it('mixed sources (200 scanned + 50 records + 10 active + 20 running) × 50 iterations < 200ms', () => {
+      const src = makeSources({ scanned: 200, records: 50, active: 10, running: 20 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50);
+      }, 50);
+      console.log(`  mixed sources: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+
+    it('heavy overlap (same IDs) × 50 iterations < 200ms', () => {
+      // Create overlapping sessions across sources
+      const scanned = Array.from({ length: 100 }, (_, i) => makeSessionInfo(i));
+      const records: SessionRecord[] = scanned.slice(0, 50).map(s => ({
+        sessionId: s.sessionId,
+        agent: s.agent,
+        cwd: s.cwd,
+        title: s.title + ' (from record)',
+        createdAt: s.createdAt,
+        lastActivityAt: s.lastActivityAt,
+      }));
+      const active: ActiveSessionSnapshot[] = scanned.slice(0, 10).map(s => ({
+        sessionId: s.sessionId,
+        agent: s.agent,
+        cwd: s.cwd,
+        title: s.title + ' (active)',
+        createdAt: s.createdAt,
+        lastActivityAt: new Date().toISOString(),
+      }));
+      const src: InventorySources = {
+        scannedSessions: scanned,
+        sessionRecords: records,
+        activeSessions: active,
+        runningSessions: [],
+        scannedAt: new Date().toISOString(),
+      };
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50);
+      }, 50);
+      console.log(`  heavy overlap: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+  });
+
+  describe('buildSessionInventoryPage - filtering', () => {
+
+    it('filter by agent on 500 sessions × 50 iterations < 200ms', () => {
+      const src = makeSources({ scanned: 500 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50, undefined, 'claude');
+      }, 50);
+      console.log(`  filter agent: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+
+    it('filter by cwd on 500 sessions × 50 iterations < 200ms', () => {
+      const src = makeSources({ scanned: 500 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50, undefined, undefined, '/repo/project-3');
+      }, 50);
+      console.log(`  filter cwd: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+
+    it('filter by search on 500 sessions × 50 iterations < 200ms', () => {
+      const src = makeSources({ scanned: 500 });
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50, undefined, undefined, undefined, 'important');
+      }, 50);
+      console.log(`  filter search: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+
+    it('search with contentMatchIds on 500 sessions × 50 iterations < 200ms', () => {
+      const src = makeSources({ scanned: 500 });
+      const contentMatchIds = new Set(
+        Array.from({ length: 50 }, (_, i) => `session-${i * 10}`),
+      );
+      const { totalMs, avgMs } = measure(() => {
+        buildSessionInventoryPage(src, 50, undefined, undefined, undefined, 'nomatch', contentMatchIds);
+      }, 50);
+      console.log(`  search+content: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+  });
+
+  describe('buildSessionInventoryPage - pagination', () => {
+
+    it('paginate through 500 sessions in pages of 50 < 500ms', () => {
+      const src = makeSources({ scanned: 500 });
+      const start = performance.now();
+      let cursor = undefined as any;
+      let totalSessions = 0;
+      let pages = 0;
+      do {
+        const page = buildSessionInventoryPage(src, 50, cursor);
+        totalSessions += page.sessions.length;
+        cursor = page.nextCursor;
+        pages++;
+      } while (cursor && pages < 20);
+      const totalMs = performance.now() - start;
+      console.log(`  pagination: ${pages} pages, ${totalSessions} sessions, ${totalMs.toFixed(2)}ms`);
+      assert.ok(totalMs < 500, `took ${totalMs.toFixed(2)}ms, expected < 500ms`);
+      assert.equal(totalSessions, 500);
+    });
+
+    it('paginate through 1000 sessions in pages of 20 < 1000ms', () => {
+      const src = makeSources({ scanned: 1000 });
+      const start = performance.now();
+      let cursor = undefined as any;
+      let totalSessions = 0;
+      let pages = 0;
+      do {
+        const page = buildSessionInventoryPage(src, 20, cursor);
+        totalSessions += page.sessions.length;
+        cursor = page.nextCursor;
+        pages++;
+      } while (cursor && pages < 100);
+      const totalMs = performance.now() - start;
+      console.log(`  pagination (small pages): ${pages} pages, ${totalSessions} sessions, ${totalMs.toFixed(2)}ms`);
+      assert.ok(totalMs < 1000, `took ${totalMs.toFixed(2)}ms, expected < 1000ms`);
+      assert.equal(totalSessions, 1000);
+    });
+  });
+});