@monotykamary/pi-ledger 0.2.0

package/extensions/pi-ledger/__tests__/helpers.ts

@@ -0,0 +1,326 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { vi } from 'vitest';
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { sidecarPathFor, type SidecarEvent } from '../index';
+
+// Minimal fakes for instantiating a CustomEditor headlessly in tests: the
+// editor wrapper delegates every keystroke to the base editor, which only
+// needs these to process a key without a real terminal. See LedgerEditor.
+const FAKE_TUI = {
+  requestRender() {},
+  requestGlobalRender() {},
+  getColumns() {
+    return 80;
+  },
+  getRows() {
+    return 24;
+  },
+};
+const FAKE_THEME = {
+  borderColor: '',
+  borderMutedColor: '',
+  text: '',
+  accent: '',
+  muted: '',
+  dim: '',
+  success: '',
+  error: '',
+  warning: '',
+  bg: (s: string) => s,
+  fg: (_c: string, s: string) => s,
+};
+// Recognizes sentinel editor keys for app actions so tests can drive the
+// LedgerEditor wrapper's dequeue/followUp branches (matched by action id, as
+// in production). Real keybindings are not needed headlessly.
+const FAKE_KB = {
+  matches: (data: string, action: string) =>
+    (action === 'app.message.dequeue' && data === 'dequeue') ||
+    (action === 'app.message.followUp' && data === 'followUp'),
+};
+
+const TEST_SESSION_ID = '019fabcd-aaaa-bbbb-cccc-dddddddddddd';
+
+export interface TestFixture {
+  mockPi: Partial<ExtensionAPI>;
+  handlers: Record<string, (...args: unknown[]) => unknown>;
+  commands: Record<
+    string,
+    {
+      description?: string;
+      handler: (args: string, ctx: ExtensionContext) => Promise<void>;
+      getArgumentCompletions?: (prefix: string) => unknown;
+    }
+  >;
+  appendEntrySpy: ReturnType<typeof vi.fn>;
+  notifySpy: ReturnType<typeof vi.fn>;
+  setStatusSpy: ReturnType<typeof vi.fn>;
+  customSpy: ReturnType<typeof vi.fn>;
+  selectSpy: ReturnType<typeof vi.fn>;
+  inputSpy: ReturnType<typeof vi.fn>;
+  registerCommandSpy: ReturnType<typeof vi.fn>;
+  setEditorComponentSpy: ReturnType<typeof vi.fn>;
+  /** Send a keystroke into the editor wrapper installed via setEditorComponent. */
+  sendEditorKey: (data: string) => void;
+  emitEvent: (event: string, payload: unknown) => void;
+  /** Invoke a lifecycle handler registered via pi.on(name, fn) with (event, ctx). */
+  run: (name: string, event: unknown) => void;
+  /** Set the value that ctx.ui.custom()'s promise resolves with (for wizard accept/dismiss). */
+  setCustomResult: (value: unknown) => void;
+  /** Set the value ctx.ui.select() resolves with (for RPC wizard/settings). */
+  setSelectResult: (value: unknown) => void;
+  /** Set the value ctx.ui.input() resolves with (for RPC settings). */
+  setInputResult: (value: unknown) => void;
+  mockEntries: Array<{ type?: string; customType?: string; data?: unknown }>;
+  mockCtx: ExtensionContext;
+  /** Overwrite the per-session sidecar event log with `events` (simulates a resumed session). */
+  seedSidecar: (events: SidecarEvent[]) => void;
+  /** Read the session's sidecar event log. */
+  readSidecarEvents: () => SidecarEvent[];
+  /** Last sidecar event of a given kind (or undefined). */
+  lastSidecarEvent: (kind: SidecarEvent['kind']) => SidecarEvent | undefined;
+  /** Delete the session's sidecar file (simulate a missing/failed read). */
+  clearSidecar: () => void;
+}
+
+export function makeTpsTelemetry(
+  overrides: {
+    generationMs?: number;
+    stallMs?: number;
+    input?: number;
+    output?: number;
+    total?: number;
+    provider?: string;
+    modelId?: string;
+  } = {}
+): unknown {
+  const {
+    generationMs = 2000,
+    stallMs = 0,
+    input = 1000,
+    output = 500,
+    total = 1500,
+    provider = 'openai',
+    modelId = 'gpt-4',
+  } = overrides;
+  return {
+    model: { provider, modelId },
+    tokens: { input, output, total },
+    timing: {
+      generationMs,
+      stallMs,
+      ttftMs: 500,
+      totalMs: 2500,
+      streamMs: 1500,
+      stallCount: 0,
+      messageCount: 1,
+    },
+    tps: 250,
+    cost: null,
+    rateUsdPerMTokens: null,
+    timestamp: Date.now(),
+  };
+}
+
+export function createTestFixture(): TestFixture {
+  const handlers: Record<string, (...args: unknown[]) => unknown> = {};
+  const commands: TestFixture['commands'] = {};
+  const appendEntrySpy = vi.fn();
+  const notifySpy = vi.fn();
+  const setStatusSpy = vi.fn();
+  const customSpy = vi.fn();
+  const selectSpy = vi.fn();
+  const inputSpy = vi.fn();
+  const registerCommandSpy = vi.fn((name: string, options: unknown) => {
+    commands[name] = options as TestFixture['commands'][string];
+  });
+  const setEditorComponentSpy = vi.fn();
+  let editorFactory:
+    | ((tui: unknown, theme: unknown, kb: unknown) => { handleInput(data: string): void })
+    | null = null;
+  let editorComponent: { handleInput(data: string): void } | null = null;
+  setEditorComponentSpy.mockImplementation((factory: unknown) => {
+    if (typeof factory === 'function') {
+      editorFactory = factory as typeof editorFactory;
+      editorComponent = null; // rebuild on reinstall (e.g. session reload)
+    }
+  });
+
+  const mockEntries: Array<{ type?: string; customType?: string; data?: unknown }> = [];
+
+  let customResult: unknown = undefined;
+  const setCustomResult = (value: unknown) => {
+    customResult = value;
+  };
+  let selectResult: unknown = undefined;
+  const setSelectResult = (value: unknown) => {
+    selectResult = value;
+  };
+  let inputResult: unknown = undefined;
+  const setInputResult = (value: unknown) => {
+    inputResult = value;
+  };
+
+  const mockCtx = {
+    hasUI: true,
+    mode: 'tui',
+    cwd: '/tmp/project',
+    ui: {
+      notify: notifySpy,
+      setStatus: setStatusSpy,
+      custom: customSpy,
+      select: selectSpy,
+      input: inputSpy,
+      setEditorComponent: setEditorComponentSpy,
+    },
+    sessionManager: {
+      getEntries: vi.fn().mockReturnValue(mockEntries),
+      getBranch: vi.fn().mockReturnValue(mockEntries),
+      getSessionId: vi.fn().mockReturnValue('019fabcd-aaaa-bbbb-cccc-dddddddddddd'),
+    },
+    modelRegistry: undefined,
+    model: undefined,
+    isIdle: vi.fn().mockReturnValue(true),
+    isProjectTrusted: vi.fn().mockReturnValue(true),
+    signal: undefined,
+    abort: vi.fn(),
+    hasPendingMessages: vi.fn().mockReturnValue(false),
+    shutdown: vi.fn(),
+    getContextUsage: vi.fn(),
+    compact: vi.fn(),
+    getSystemPrompt: vi.fn(),
+  } as unknown as ExtensionContext;
+
+  const eventListeners = new Map<string, ((payload: unknown) => void)[]>();
+  const emitEvent = (event: string, payload: unknown) => {
+    for (const listener of eventListeners.get(event) ?? []) listener(payload);
+  };
+  const run = (name: string, event: unknown) => {
+    return handlers[name]?.(event, mockCtx);
+  };
+
+  const mockPi: Partial<ExtensionAPI> = {
+    on: vi.fn((event: string, handler: (...args: unknown[]) => unknown) => {
+      handlers[event] = handler;
+      return mockPi as ExtensionAPI;
+    }) as unknown as ExtensionAPI['on'],
+    appendEntry: appendEntrySpy,
+    registerCommand: registerCommandSpy as unknown as ExtensionAPI['registerCommand'],
+    events: {
+      on: vi.fn((event: string, listener: (payload: unknown) => void) => {
+        const list = eventListeners.get(event) ?? [];
+        list.push(listener);
+        eventListeners.set(event, list);
+        return () => {};
+      }) as unknown as ExtensionAPI['events']['on'],
+      emit: vi.fn(),
+    } as unknown as ExtensionAPI['events'],
+  };
+
+  // ctx.ui.custom: by default resolve immediately without invoking the factory
+  // (avoids needing a terminal). Tests can set a result to simulate a choice.
+  customSpy.mockImplementation(() => Promise.resolve(customResult));
+  selectSpy.mockImplementation(() => Promise.resolve(selectResult));
+  inputSpy.mockImplementation(() => Promise.resolve(inputResult));
+
+  const sidecarFile = () => sidecarPathFor(TEST_SESSION_ID);
+  const seedSidecar = (events: SidecarEvent[]) => {
+    fs.mkdirSync(path.dirname(sidecarFile()), { recursive: true });
+    fs.writeFileSync(sidecarFile(), events.map((e) => JSON.stringify(e)).join('\n') + '\n');
+  };
+  const readSidecarEvents = (): SidecarEvent[] => {
+    try {
+      return fs
+        .readFileSync(sidecarFile(), 'utf8')
+        .split('\n')
+        .filter((l) => l.trim())
+        .map((l) => JSON.parse(l) as SidecarEvent);
+    } catch {
+      return [];
+    }
+  };
+  const lastSidecarEvent = (kind: SidecarEvent['kind']): SidecarEvent | undefined => {
+    const events = readSidecarEvents();
+    for (let i = events.length - 1; i >= 0; i--) if (events[i]!.kind === kind) return events[i]!;
+    return undefined;
+  };
+  const clearSidecar = () => {
+    try {
+      fs.rmSync(sidecarFile(), { force: true });
+    } catch {
+      // ignore
+    }
+  };
+
+  const sendEditorKey = (data: string) => {
+    if (!editorFactory) return;
+    if (!editorComponent) editorComponent = editorFactory(FAKE_TUI, FAKE_THEME, FAKE_KB);
+    editorComponent.handleInput(data);
+  };
+
+  return {
+    mockPi,
+    handlers,
+    commands,
+    appendEntrySpy,
+    notifySpy,
+    setStatusSpy,
+    customSpy,
+    selectSpy,
+    inputSpy,
+    registerCommandSpy,
+    setEditorComponentSpy,
+    sendEditorKey,
+    emitEvent,
+    run,
+    setCustomResult,
+    setSelectResult,
+    setInputResult,
+    mockEntries,
+    mockCtx,
+    seedSidecar,
+    readSidecarEvents,
+    lastSidecarEvent,
+    clearSidecar,
+  };
+}
+
+export async function activateExtension(fixture: TestFixture): Promise<void> {
+  const { default: ledgerExtension } = await import('../index.js');
+  ledgerExtension(fixture.mockPi as ExtensionAPI);
+}
+
+/** An assistant message for the message_start/update/end hooks (fallback timing). */
+export function makeAssistantMessage(
+  overrides: {
+    input?: number;
+    output?: number;
+    totalTokens?: number;
+    provider?: string;
+    model?: string;
+  } = {}
+): unknown {
+  const {
+    input = 100,
+    output = 50,
+    totalTokens = 150,
+    provider = 'openai',
+    model = 'gpt-4',
+  } = overrides;
+  return {
+    role: 'assistant',
+    content: [{ type: 'text', text: 'ok' }],
+    provider,
+    model,
+    usage: {
+      input,
+      output,
+      totalTokens,
+      cacheRead: 0,
+      cacheWrite: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+    stopReason: 'stop',
+    timestamp: Date.now(),
+  };
+}