@vibelet/cli 0.1.37 → 1.0.0

package/src/session-store.test.ts

@@ -1,276 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, rm } from 'fs/promises';
-import { readFileSync, mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
-import type { SessionRecord } from './session-store.js';
-
-// We need to override SESSION_STORE_PATH before importing SessionStore.
-// Use a dynamic approach: create the store, then replace its internals.
-
-async function withTempStore(fn: (storePath: string) => Promise<void>): Promise<void> {
-  const dir = await mkdtemp(join(tmpdir(), 'ss-test-'));
-  const storePath = join(dir, 'sessions.json');
-  try {
-    await fn(storePath);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-function makeRecord(overrides: Partial<SessionRecord> & { sessionId: string }): SessionRecord {
-  return {
-    agent: 'claude',
-    cwd: '/test',
-    title: 'Test',
-    createdAt: '2026-01-01T00:00:00.000Z',
-    lastActivityAt: '2026-01-01T00:00:00.000Z',
-    ...overrides,
-  };
-}
-
-// Import SessionStore and override its disk path for testing
-async function createTestStore(storePath: string, initialRecords?: SessionRecord[]) {
-  if (initialRecords) {
-    mkdirSync(dirname(storePath), { recursive: true });
-    writeFileSync(storePath, JSON.stringify({
-      records: initialRecords,
-      deletedSessionIds: [],
-    }));
-  }
-  const { SessionStore } = await import('./session-store.js');
-  const store = new SessionStore();
-  // Override path and records for isolated testing
-  (store as any).records = initialRecords ?? [];
-  (store as any).deletedSessionIds = new Set<string>();
-  // Make save synchronous and write to our temp path
-  (store as any).saveToDisk = () => {
-    mkdirSync(dirname(storePath), { recursive: true });
-    writeFileSync(storePath, JSON.stringify({
-      records: (store as any).records,
-      deletedSessionIds: [...(store as any).deletedSessionIds],
-    }, null, 2));
-  };
-  (store as any).scheduleSave = () => (store as any).saveToDisk();
-  return store;
-}
-
-test('getAll: returns empty array initially', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    assert.deepEqual(store.getAll(), []);
-  });
-});
-
-test('upsert: inserts new record at beginning', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    const r1 = makeRecord({ sessionId: 's1' });
-    const r2 = makeRecord({ sessionId: 's2' });
-
-    store.upsert(r1);
-    store.upsert(r2);
-
-    const all = store.getAll();
-    assert.equal(all.length, 2);
-    assert.equal(all[0].sessionId, 's2');
-    assert.equal(all[1].sessionId, 's1');
-  });
-});
-
-test('upsert: updates existing record in place', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1', title: 'Original' }));
-    store.upsert(makeRecord({ sessionId: 's1', title: 'Updated' }));
-
-    const all = store.getAll();
-    assert.equal(all.length, 1);
-    assert.equal(all[0].title, 'Updated');
-  });
-});
-
-test('find: returns matching record', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1', title: 'Found' }));
-    store.upsert(makeRecord({ sessionId: 's2', title: 'Other' }));
-
-    const found = store.find('s1');
-    assert.ok(found);
-    assert.equal(found.title, 'Found');
-  });
-});
-
-test('find: returns undefined for missing record', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    assert.equal(store.find('nonexistent'), undefined);
-  });
-});
-
-test('remove: removes matching record', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1' }));
-    store.upsert(makeRecord({ sessionId: 's2' }));
-
-    store.remove('s1');
-
-    assert.equal(store.getAll().length, 1);
-    assert.equal(store.find('s1'), undefined);
-    assert.equal(store.isDeleted('s1'), true);
-    assert.ok(store.find('s2'));
-  });
-});
-
-test('remove: no-op for missing record', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1' }));
-
-    store.remove('nonexistent');
-
-    assert.equal(store.getAll().length, 1);
-  });
-});
-
-test('flushSync: persists to disk', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1', title: 'Persisted' }));
-    store.flushSync();
-
-    const data = JSON.parse(readFileSync(storePath, 'utf-8'));
-    assert.equal(data.records.length, 1);
-    assert.equal(data.records[0].sessionId, 's1');
-    assert.equal(data.records[0].title, 'Persisted');
-    assert.deepEqual(data.deletedSessionIds, []);
-  });
-});
-
-test('upsert: triggers save to disk', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1' }));
-
-    // scheduleSave is synchronous in our test setup
-    const data = JSON.parse(readFileSync(storePath, 'utf-8'));
-    assert.equal(data.records.length, 1);
-    assert.deepEqual(data.deletedSessionIds, []);
-  });
-});
-
-test('remove: triggers save to disk', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1' }));
-    store.upsert(makeRecord({ sessionId: 's2' }));
-    store.remove('s1');
-
-    const data = JSON.parse(readFileSync(storePath, 'utf-8'));
-    assert.equal(data.records.length, 1);
-    assert.equal(data.records[0].sessionId, 's2');
-    assert.deepEqual(data.deletedSessionIds, ['s1']);
-  });
-});
-
-test('upsert: clears tombstone for a recreated session', async () => {
-  await withTempStore(async (storePath) => {
-    const store = await createTestStore(storePath);
-    store.upsert(makeRecord({ sessionId: 's1' }));
-    store.remove('s1');
-
-    assert.equal(store.isDeleted('s1'), true);
-
-    store.upsert(makeRecord({ sessionId: 's1', title: 'Recreated' }));
-
-    assert.equal(store.isDeleted('s1'), false);
-    assert.equal(store.find('s1')?.title, 'Recreated');
-  });
-});
-
-test('loadFromDisk: preserves accepted client message ids and trims oversized arrays', async () => {
-  await withTempStore(async (storePath) => {
-    const initial = makeRecord({
-      sessionId: 's1',
-      acceptedClientMessageIds: Array.from({ length: 205 }, (_, index) => `cm_${index}`),
-    });
-    const { normalizeSessionRecord } = await import('./session-store.js');
-    const record = normalizeSessionRecord(initial);
-
-    assert.ok(record);
-    assert.equal(record.acceptedClientMessageIds?.length, 200);
-    assert.equal(record.acceptedClientMessageIds?.[0], 'cm_5');
-    assert.equal(record.acceptedClientMessageIds?.[199], 'cm_204');
-  });
-});
-
-test('loadFromDisk: backfills missing accepted client message ids for legacy records', async () => {
-  await withTempStore(async (storePath) => {
-    const legacyRecord = makeRecord({ sessionId: 'legacy' });
-    delete (legacyRecord as SessionRecord & { acceptedClientMessageIds?: string[] }).acceptedClientMessageIds;
-    const { normalizeSessionRecord } = await import('./session-store.js');
-    const record = normalizeSessionRecord(legacyRecord);
-
-    assert.ok(record);
-    assert.deepEqual(record.acceptedClientMessageIds, []);
-  });
-});
-
-test('normalizeSessionRecord preserves a valid pending approval payload', async () => {
-  await withTempStore(async () => {
-    const { normalizeSessionRecord } = await import('./session-store.js');
-    const record = normalizeSessionRecord(makeRecord({
-      sessionId: 'pending-approval',
-      pendingApproval: {
-        requestId: 'req-1',
-        toolName: 'Bash',
-        input: { command: 'pwd' },
-        description: 'Run pwd',
-        approvalContext: {
-          provider: 'codex',
-          kind: 'command-execution',
-          rpcId: 42,
-        },
-      },
-    }));
-
-    assert.deepEqual(record.pendingApproval, {
-      requestId: 'req-1',
-      toolName: 'Bash',
-      input: { command: 'pwd' },
-      description: 'Run pwd',
-      approvalContext: {
-        provider: 'codex',
-        kind: 'command-execution',
-        rpcId: 42,
-      },
-    });
-  });
-});
-
-test('normalizeSessionStoreDiskState: supports legacy array-only store files', async () => {
-  const { normalizeSessionStoreDiskState } = await import('./session-store.js');
-  const legacyRecord = makeRecord({ sessionId: 'legacy-array' });
-  delete (legacyRecord as SessionRecord & { acceptedClientMessageIds?: string[] }).acceptedClientMessageIds;
-
-  const state = normalizeSessionStoreDiskState([legacyRecord]);
-
-  assert.equal(state.records.length, 1);
-  assert.equal(state.records[0].sessionId, 'legacy-array');
-  assert.deepEqual(state.records[0].acceptedClientMessageIds, []);
-  assert.deepEqual(state.deletedSessionIds, []);
-});
-
-test('normalizeSessionStoreDiskState: sanitizes deletedSessionIds entries', async () => {
-  const { normalizeSessionStoreDiskState } = await import('./session-store.js');
-
-  const state = normalizeSessionStoreDiskState({
-    records: [makeRecord({ sessionId: 'kept' })],
-    deletedSessionIds: ['dup', '', 'dup', null, 123, 'ok'],
-  });
-
-  assert.deepEqual(state.deletedSessionIds, ['dup', 'ok']);
-});

package/src/session-store.ts

@@ -1,202 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-import type { AgentType, ApprovalMode, ApprovalRequestPayload } from '@vibelet/shared';
-import { SESSION_STORE_PATH } from './paths.js';
-
-export interface SessionRecord {
-  sessionId: string;
-  agent: AgentType;
-  cwd: string;
-  approvalMode?: ApprovalMode;
-  acceptedClientMessageIds?: string[];
-  pendingApproval?: ApprovalRequestPayload;
-  title: string;
-  createdAt: string;
-  lastActivityAt: string;
-  /** True for sessions created from the Vibelet app. */
-  managed?: boolean;
-  /** True if the session was responding when last persisted. */
-  isResponding?: boolean;
-}
-
-interface SessionStoreDiskState {
-  records: SessionRecord[];
-  deletedSessionIds: string[];
-}
-
-const DEBOUNCE_MS = 500;
-const MAX_ACCEPTED_CLIENT_MESSAGE_IDS = 200;
-
-function sanitizeAcceptedClientMessageIds(ids: unknown): string[] {
-  if (!Array.isArray(ids)) return [];
-  const sanitized = ids.filter((value): value is string => typeof value === 'string' && value.length > 0);
-  if (sanitized.length <= MAX_ACCEPTED_CLIENT_MESSAGE_IDS) {
-    return sanitized;
-  }
-  return sanitized.slice(-MAX_ACCEPTED_CLIENT_MESSAGE_IDS);
-}
-
-function sanitizeDeletedSessionIds(ids: unknown): string[] {
-  if (!Array.isArray(ids)) return [];
-  const result: string[] = [];
-  for (const value of ids) {
-    if (typeof value !== 'string' || value.length === 0 || result.includes(value)) continue;
-    result.push(value);
-  }
-  return result;
-}
-
-function sanitizeApprovalRequest(value: unknown): ApprovalRequestPayload | undefined {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return undefined;
-  }
-
-  const candidate = value as Partial<ApprovalRequestPayload>;
-  const requestId = typeof candidate.requestId === 'string' ? candidate.requestId : '';
-  const toolName = typeof candidate.toolName === 'string' ? candidate.toolName : '';
-  const description = typeof candidate.description === 'string' ? candidate.description : '';
-  const input = candidate.input && typeof candidate.input === 'object' && !Array.isArray(candidate.input)
-    ? candidate.input as Record<string, unknown>
-    : {};
-
-  if (!requestId || !toolName || !description) {
-    return undefined;
-  }
-
-  const approvalContext = candidate.approvalContext;
-  if (
-    approvalContext
-    && typeof approvalContext === 'object'
-    && !Array.isArray(approvalContext)
-    && approvalContext.provider === 'codex'
-    && typeof approvalContext.kind === 'string'
-    && typeof approvalContext.rpcId === 'number'
-  ) {
-    return {
-      requestId,
-      toolName,
-      input,
-      description,
-      approvalContext: {
-        provider: 'codex',
-        kind: approvalContext.kind,
-        rpcId: approvalContext.rpcId,
-        ...(typeof approvalContext.questionId === 'string' ? { questionId: approvalContext.questionId } : {}),
-        ...(typeof approvalContext.approveLabel === 'string' ? { approveLabel: approvalContext.approveLabel } : {}),
-        ...(typeof approvalContext.denyLabel === 'string' ? { denyLabel: approvalContext.denyLabel } : {}),
-      },
-    };
-  }
-
-  return {
-    requestId,
-    toolName,
-    input,
-    description,
-  };
-}
-
-export function normalizeSessionRecord(record: SessionRecord & { lastActivityAt?: string }): SessionRecord {
-  return {
-    ...record,
-    lastActivityAt: record.lastActivityAt ?? record.createdAt,
-    acceptedClientMessageIds: sanitizeAcceptedClientMessageIds(record.acceptedClientMessageIds),
-    pendingApproval: sanitizeApprovalRequest(record.pendingApproval),
-  };
-}
-
-export function normalizeSessionStoreDiskState(parsed: unknown): SessionStoreDiskState {
-  if (Array.isArray(parsed)) {
-    return {
-      records: parsed.map(normalizeSessionRecord),
-      deletedSessionIds: [],
-    };
-  }
-  if (parsed && typeof parsed === 'object') {
-    const state = parsed as Partial<SessionStoreDiskState>;
-    return {
-      records: Array.isArray(state.records) ? state.records.map(normalizeSessionRecord) : [],
-      deletedSessionIds: sanitizeDeletedSessionIds(state.deletedSessionIds),
-    };
-  }
-  return { records: [], deletedSessionIds: [] };
-}
-
-export class SessionStore {
-  private records: SessionRecord[];
-  private deletedSessionIds: Set<string>;
-  private debounceTimer: ReturnType<typeof setTimeout> | null = null;
-
-  constructor() {
-    const state = this.loadFromDisk();
-    this.records = state.records;
-    this.deletedSessionIds = new Set(state.deletedSessionIds);
-  }
-
-  getAll(): SessionRecord[] {
-    return this.records;
-  }
-
-  getDeletedSessionIds(): string[] {
-    return [...this.deletedSessionIds];
-  }
-
-  find(sessionId: string): SessionRecord | undefined {
-    return this.records.find(r => r.sessionId === sessionId);
-  }
-
-  isDeleted(sessionId: string): boolean {
-    return this.deletedSessionIds.has(sessionId);
-  }
-
-  upsert(record: SessionRecord): void {
-    this.deletedSessionIds.delete(record.sessionId);
-    const index = this.records.findIndex(r => r.sessionId === record.sessionId);
-    if (index >= 0) {
-      this.records[index] = record;
-    } else {
-      this.records.unshift(record);
-    }
-    this.scheduleSave();
-  }
-
-  remove(sessionId: string): void {
-    this.records = this.records.filter(r => r.sessionId !== sessionId);
-    this.deletedSessionIds.add(sessionId);
-    this.scheduleSave();
-  }
-
-  flushSync(): void {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-    this.saveToDisk();
-  }
-
-  private scheduleSave(): void {
-    if (this.debounceTimer) clearTimeout(this.debounceTimer);
-    this.debounceTimer = setTimeout(() => {
-      this.debounceTimer = null;
-      this.saveToDisk();
-    }, DEBOUNCE_MS);
-  }
-
-  private loadFromDisk(): SessionStoreDiskState {
-    try {
-      const data = readFileSync(SESSION_STORE_PATH, 'utf-8');
-      return normalizeSessionStoreDiskState(JSON.parse(data) as unknown);
-    } catch {
-      // Ignore invalid or missing store files and start from an empty state.
-    }
-    return { records: [], deletedSessionIds: [] };
-  }
-
-  private saveToDisk(): void {
-    mkdirSync(dirname(SESSION_STORE_PATH), { recursive: true });
-    writeFileSync(SESSION_STORE_PATH, JSON.stringify({
-      records: this.records,
-      deletedSessionIds: [...this.deletedSessionIds],
-    }, null, 2));
-  }
-}

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

@@ -1,118 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  sanitizeSessionTitle,
-  isIdLikeSessionTitle,
-  isFallbackSessionTitle,
-  titleFromFirstSentence,
-  preferSessionTitle,
-} from './session-title.js';
-
-function measure(fn: () => void, iterations: number): { totalMs: number; avgMs: number } {
-  const start = performance.now();
-  for (let i = 0; i < iterations; i++) fn();
-  const totalMs = performance.now() - start;
-  return { totalMs, avgMs: totalMs / iterations };
-}
-
-const ITERATIONS = 10_000;
-
-describe('session-title performance', () => {
-  const longText = 'a'.repeat(500);
-  const multiLine = Array.from({ length: 50 }, (_, i) => `Line ${i}: some content here`).join('\n');
-  const uuid = '019d03e3-2672-7011-9c6d-5ba083b71111';
-  const hexId = 'abcdef1234567890abcdef';
-
-  it(`sanitizeSessionTitle × ${ITERATIONS} short strings < 50ms`, () => {
-    const { totalMs } = measure(() => sanitizeSessionTitle('  hello   world  '), ITERATIONS);
-    console.log(`  sanitizeSessionTitle (short): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
-  });
-
-  it(`sanitizeSessionTitle × ${ITERATIONS} long strings < 100ms`, () => {
-    const { totalMs } = measure(() => sanitizeSessionTitle(longText), ITERATIONS);
-    console.log(`  sanitizeSessionTitle (long): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
-  });
-
-  it(`isIdLikeSessionTitle × ${ITERATIONS} UUID checks < 50ms`, () => {
-    const { totalMs } = measure(() => isIdLikeSessionTitle(uuid), ITERATIONS);
-    console.log(`  isIdLikeSessionTitle (uuid): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
-  });
-
-  it(`isIdLikeSessionTitle × ${ITERATIONS} hex checks < 50ms`, () => {
-    const { totalMs } = measure(() => isIdLikeSessionTitle(hexId), ITERATIONS);
-    console.log(`  isIdLikeSessionTitle (hex): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
-  });
-
-  it(`isIdLikeSessionTitle × ${ITERATIONS} normal title < 50ms`, () => {
-    const { totalMs } = measure(() => isIdLikeSessionTitle('Fix the login bug'), ITERATIONS);
-    console.log(`  isIdLikeSessionTitle (normal): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
-  });
-
-  it(`isFallbackSessionTitle × ${ITERATIONS} mixed checks < 100ms`, () => {
-    const titles = ['New session', 'Resumed session', uuid, 'Fix bug', hexId, 'Untitled session'];
-    const { totalMs } = measure(() => {
-      for (const title of titles) isFallbackSessionTitle(title);
-    }, ITERATIONS);
-    console.log(`  isFallbackSessionTitle (mixed×6): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
-  });
-
-  it(`titleFromFirstSentence × ${ITERATIONS} single line < 50ms`, () => {
-    const { totalMs } = measure(() => titleFromFirstSentence('Fix the login bug. Then deploy.'), ITERATIONS);
-    console.log(`  titleFromFirstSentence (single): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
-  });
-
-  it(`titleFromFirstSentence × ${ITERATIONS} multi-line < 200ms`, () => {
-    const { totalMs } = measure(() => titleFromFirstSentence(multiLine), ITERATIONS);
-    console.log(`  titleFromFirstSentence (multi): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
-  });
-
-  it(`titleFromFirstSentence × ${ITERATIONS} with meta prefix noise < 200ms`, () => {
-    const text = '<environment_context>setup\n# AGENTS.md instructions for project\nActual title here. More text.';
-    const { totalMs } = measure(() => titleFromFirstSentence(text), ITERATIONS);
-    console.log(`  titleFromFirstSentence (meta noise): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
-  });
-
-  it(`titleFromFirstSentence × ${ITERATIONS} long truncation < 100ms`, () => {
-    const sentence = 'A'.repeat(200) + '. Done.';
-    const { totalMs } = measure(() => titleFromFirstSentence(sentence, 80), ITERATIONS);
-    console.log(`  titleFromFirstSentence (truncation): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
-  });
-
-  it(`preferSessionTitle × ${ITERATIONS} candidate chain < 100ms`, () => {
-    const candidates: Array<string | null | undefined> = [
-      null,
-      undefined,
-      'New session',
-      uuid,
-      'Actual good title',
-    ];
-    const { totalMs } = measure(() => preferSessionTitle(candidates, 'fallback text here'), ITERATIONS);
-    console.log(`  preferSessionTitle (chain): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
-  });
-
-  it(`preferSessionTitle × ${ITERATIONS} fallback to text < 200ms`, () => {
-    const candidates: Array<string | null | undefined> = [null, 'New session', uuid];
-    const { totalMs } = measure(() => preferSessionTitle(candidates, multiLine), ITERATIONS);
-    console.log(`  preferSessionTitle (fallback): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
-  });
-
-  // CJK sentence boundary test
-  it(`titleFromFirstSentence × ${ITERATIONS} CJK text < 100ms`, () => {
-    const text = '修复登录页面的样式问题。然后部署到生产环境。';
-    const { totalMs } = measure(() => titleFromFirstSentence(text), ITERATIONS);
-    console.log(`  titleFromFirstSentence (CJK): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
-    assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
-  });
-});