retestkit 1.4.1 → 1.5.0

package/src/progress/index.test.ts

@@ -1,327 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  createCancellationRegistry,
-  createProgressEmitter,
-  calculateBudgetStatus,
-  CancellationError,
-} from "./index.js";
-import type { Logger } from "../logger.js";
-import type { ClientCapabilities } from "../types/capabilities.js";
-
-describe("progress", () => {
-  let mockLogger: Logger;
-
-  beforeEach(() => {
-    mockLogger = {
-      debug: vi.fn(),
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-      setLevel: vi.fn(),
-      withCorrelation: vi.fn().mockReturnThis(),
-    } as unknown as Logger;
-  });
-
-  describe("CancellationRegistry", () => {
-    it("registers and tracks requests", () => {
-      const registry = createCancellationRegistry(mockLogger);
-
-      registry.register("request-1");
-      expect(registry.isCancelled("request-1")).toBe(false);
-    });
-
-    it("marks requests as cancelled", () => {
-      const registry = createCancellationRegistry(mockLogger);
-
-      registry.register("request-1");
-      registry.cancel("request-1");
-      expect(registry.isCancelled("request-1")).toBe(true);
-    });
-
-    it("does not cancel unregistered requests", () => {
-      const registry = createCancellationRegistry(mockLogger);
-
-      registry.cancel("unknown-request");
-      expect(registry.isCancelled("unknown-request")).toBe(false);
-    });
-
-    it("unregisters requests and clears cancellation status", () => {
-      const registry = createCancellationRegistry(mockLogger);
-
-      registry.register("request-1");
-      registry.cancel("request-1");
-      registry.unregister("request-1");
-      expect(registry.isCancelled("request-1")).toBe(false);
-    });
-
-    it("checkCancelled throws for cancelled requests", () => {
-      const registry = createCancellationRegistry(mockLogger);
-
-      registry.register("request-1");
-      registry.cancel("request-1");
-
-      expect(() => registry.checkCancelled("request-1")).toThrow(
-        CancellationError
-      );
-    });
-
-    it("checkCancelled does not throw for active requests", () => {
-      const registry = createCancellationRegistry(mockLogger);
-
-      registry.register("request-1");
-
-      expect(() => registry.checkCancelled("request-1")).not.toThrow();
-    });
-
-    it("handles multiple concurrent requests", () => {
-      const registry = createCancellationRegistry(mockLogger);
-
-      registry.register("request-1");
-      registry.register("request-2");
-      registry.register("request-3");
-
-      registry.cancel("request-2");
-
-      expect(registry.isCancelled("request-1")).toBe(false);
-      expect(registry.isCancelled("request-2")).toBe(true);
-      expect(registry.isCancelled("request-3")).toBe(false);
-    });
-  });
-
-  describe("CancellationError", () => {
-    it("has correct name and message", () => {
-      const error = new CancellationError("request-123");
-
-      expect(error.name).toBe("CancellationError");
-      expect(error.message).toBe("Request request-123 was cancelled");
-      expect(error.requestId).toBe("request-123");
-    });
-
-    it("is instanceof Error", () => {
-      const error = new CancellationError("request-123");
-      expect(error instanceof Error).toBe(true);
-    });
-  });
-
-  describe("ProgressEmitter", () => {
-    it("emits progress notifications when capability is available", async () => {
-      const sendNotification = vi.fn().mockResolvedValue(undefined);
-      const capabilities: ClientCapabilities = {
-        sampling: true,
-        elicitation: false,
-        logging: false,
-        progress: true,
-        resourcesListChanged: false,
-        resourcesSubscribe: false,
-        protocolVersion: "2025-06-18",
-      };
-
-      const emitter = createProgressEmitter(
-        sendNotification,
-        capabilities,
-        mockLogger
-      );
-
-      emitter.emit({
-        progressToken: "token-1",
-        progress: 5,
-        total: 10,
-        message: "Processing step 5",
-      });
-
-      expect(sendNotification).toHaveBeenCalledWith("notifications/progress", {
-        progressToken: "token-1",
-        progress: 5,
-        total: 10,
-      });
-    });
-
-    it("skips notification when capability is not available", () => {
-      const sendNotification = vi.fn().mockResolvedValue(undefined);
-      const capabilities: ClientCapabilities = {
-        sampling: false,
-        elicitation: false,
-        logging: false,
-        progress: false,
-        resourcesListChanged: false,
-        resourcesSubscribe: false,
-        protocolVersion: "2025-06-18",
-      };
-
-      const emitter = createProgressEmitter(
-        sendNotification,
-        capabilities,
-        mockLogger
-      );
-
-      emitter.emit({
-        progressToken: "token-1",
-        progress: 5,
-        total: 10,
-      });
-
-      expect(sendNotification).not.toHaveBeenCalled();
-      expect(mockLogger.debug).toHaveBeenCalledWith(
-        "Progress notification skipped (not supported)",
-        expect.any(Object)
-      );
-    });
-
-    it("reports hasProgress correctly", () => {
-      const sendNotification = vi.fn().mockResolvedValue(undefined);
-
-      const withProgress = createProgressEmitter(
-        sendNotification,
-        { progress: true } as ClientCapabilities,
-        mockLogger
-      );
-
-      const withoutProgress = createProgressEmitter(
-        sendNotification,
-        { progress: false } as ClientCapabilities,
-        mockLogger
-      );
-
-      expect(withProgress.hasProgress()).toBe(true);
-      expect(withoutProgress.hasProgress()).toBe(false);
-    });
-
-    it("handles notification failures gracefully", async () => {
-      const sendNotification = vi
-        .fn()
-        .mockRejectedValue(new Error("Network error"));
-      const capabilities: ClientCapabilities = {
-        sampling: true,
-        elicitation: false,
-        logging: false,
-        progress: true,
-        resourcesListChanged: false,
-        resourcesSubscribe: false,
-        protocolVersion: "2025-06-18",
-      };
-
-      const emitter = createProgressEmitter(
-        sendNotification,
-        capabilities,
-        mockLogger
-      );
-
-      // Should not throw
-      emitter.emit({
-        progressToken: "token-1",
-        progress: 5,
-        total: 10,
-      });
-
-      // Wait for async error handling
-      await new Promise((resolve) => setTimeout(resolve, 10));
-
-      expect(mockLogger.warn).toHaveBeenCalledWith(
-        "Failed to emit progress notification",
-        expect.objectContaining({ error: "Network error" })
-      );
-    });
-  });
-
-  describe("calculateBudgetStatus", () => {
-    it("calculates remaining budget correctly", () => {
-      const now = Date.now();
-      const startTime = now - 5 * 60 * 1000; // 5 minutes ago
-
-      const status = calculateBudgetStatus({
-        stepsUsed: 20,
-        maxSteps: 50,
-        startTime,
-        maxMinutes: 30,
-        pagesVisited: 5,
-        maxPages: 20,
-      });
-
-      expect(status.stepsUsed).toBe(20);
-      expect(status.stepsRemaining).toBe(30);
-      expect(status.minutesUsed).toBeCloseTo(5, 0);
-      expect(status.minutesRemaining).toBeCloseTo(25, 0);
-      expect(status.pagesVisited).toBe(5);
-      expect(status.pagesRemaining).toBe(15);
-      expect(status.isExhausted).toBe(false);
-    });
-
-    it("detects exhausted steps budget", () => {
-      const status = calculateBudgetStatus({
-        stepsUsed: 50,
-        maxSteps: 50,
-        startTime: Date.now(),
-        maxMinutes: 30,
-        pagesVisited: 5,
-        maxPages: 20,
-      });
-
-      expect(status.isExhausted).toBe(true);
-      expect(status.exhaustedReason).toBe("maxSteps limit reached");
-      expect(status.stepsRemaining).toBe(0);
-    });
-
-    it("detects exhausted time budget", () => {
-      const startTime = Date.now() - 35 * 60 * 1000; // 35 minutes ago
-
-      const status = calculateBudgetStatus({
-        stepsUsed: 20,
-        maxSteps: 50,
-        startTime,
-        maxMinutes: 30,
-        pagesVisited: 5,
-        maxPages: 20,
-      });
-
-      expect(status.isExhausted).toBe(true);
-      expect(status.exhaustedReason).toBe("maxMinutes timeout reached");
-      expect(status.minutesRemaining).toBe(0);
-    });
-
-    it("detects exhausted pages budget", () => {
-      const status = calculateBudgetStatus({
-        stepsUsed: 20,
-        maxSteps: 50,
-        startTime: Date.now(),
-        maxMinutes: 30,
-        pagesVisited: 20,
-        maxPages: 20,
-      });
-
-      expect(status.isExhausted).toBe(true);
-      expect(status.exhaustedReason).toBe("maxPages limit reached");
-      expect(status.pagesRemaining).toBe(0);
-    });
-
-    it("prevents negative remaining values", () => {
-      const status = calculateBudgetStatus({
-        stepsUsed: 100,
-        maxSteps: 50,
-        startTime: Date.now() - 60 * 60 * 1000, // 1 hour ago
-        maxMinutes: 30,
-        pagesVisited: 50,
-        maxPages: 20,
-      });
-
-      expect(status.stepsRemaining).toBe(0);
-      expect(status.minutesRemaining).toBe(0);
-      expect(status.pagesRemaining).toBe(0);
-    });
-
-    it("rounds minutes to one decimal place", () => {
-      const startTime = Date.now() - 7.333 * 60 * 1000;
-
-      const status = calculateBudgetStatus({
-        stepsUsed: 0,
-        maxSteps: 50,
-        startTime,
-        maxMinutes: 30,
-        pagesVisited: 0,
-        maxPages: 20,
-      });
-
-      // Should be rounded to one decimal
-      expect(status.minutesUsed.toString()).toMatch(/^\d+\.?\d?$/);
-    });
-  });
-});

package/src/progress/index.ts

@@ -1,170 +0,0 @@
-import type { Logger } from "../logger.js";
-import type { ClientCapabilities } from "../types/capabilities.js";
-import type { ProgressInfo, CancelledCallback } from "./types.js";
-
-export * from "./types.js";
-
-export interface CancellationRegistry {
-  register(requestId: string): void;
-  unregister(requestId: string): void;
-  isCancelled(requestId: string): boolean;
-  cancel(requestId: string): void;
-  checkCancelled(requestId: string): void;
-}
-
-export interface ProgressEmitter {
-  emit(info: ProgressInfo): void;
-  hasProgress(): boolean;
-}
-
-export function createCancellationRegistry(
-  logger: Logger
-): CancellationRegistry {
-  const cancelledRequests = new Set<string>();
-  const activeRequests = new Set<string>();
-
-  return {
-    register(requestId: string): void {
-      activeRequests.add(requestId);
-      logger.debug("Request registered for cancellation tracking", {
-        requestId,
-      });
-    },
-
-    unregister(requestId: string): void {
-      activeRequests.delete(requestId);
-      cancelledRequests.delete(requestId);
-      logger.debug("Request unregistered from cancellation tracking", {
-        requestId,
-      });
-    },
-
-    isCancelled(requestId: string): boolean {
-      return cancelledRequests.has(requestId);
-    },
-
-    cancel(requestId: string): void {
-      if (activeRequests.has(requestId)) {
-        cancelledRequests.add(requestId);
-        logger.info("Request marked as cancelled", { requestId });
-      }
-    },
-
-    checkCancelled(requestId: string): void {
-      if (cancelledRequests.has(requestId)) {
-        throw new CancellationError(requestId);
-      }
-    },
-  };
-}
-
-export class CancellationError extends Error {
-  public readonly requestId: string;
-
-  constructor(requestId: string) {
-    super(`Request ${requestId} was cancelled`);
-    this.name = "CancellationError";
-    this.requestId = requestId;
-  }
-}
-
-export function createProgressEmitter(
-  sendNotification: (method: string, params: unknown) => Promise<void>,
-  capabilities: ClientCapabilities,
-  logger: Logger
-): ProgressEmitter {
-  const hasProgressCapability = capabilities.progress;
-
-  return {
-    emit(info: ProgressInfo): void {
-      if (!hasProgressCapability) {
-        logger.debug("Progress notification skipped (not supported)", {
-          token: info.progressToken,
-          progress: info.progress,
-        });
-        return;
-      }
-
-      const notification = {
-        progressToken: info.progressToken,
-        progress: info.progress,
-        total: info.total,
-      };
-
-      logger.debug("Emitting progress notification", {
-        ...notification,
-        message: info.message,
-        budgetStatus: info.budgetStatus,
-      });
-
-      sendNotification("notifications/progress", notification).catch(
-        (error) => {
-          logger.warn("Failed to emit progress notification", {
-            error: error instanceof Error ? error.message : "Unknown error",
-          });
-        }
-      );
-    },
-
-    hasProgress(): boolean {
-      return hasProgressCapability;
-    },
-  };
-}
-
-export function calculateBudgetStatus(params: {
-  stepsUsed: number;
-  maxSteps: number;
-  startTime: number;
-  maxMinutes: number;
-  pagesVisited: number;
-  maxPages: number;
-}): {
-  stepsUsed: number;
-  stepsRemaining: number;
-  minutesUsed: number;
-  minutesRemaining: number;
-  pagesVisited: number;
-  pagesRemaining: number;
-  isExhausted: boolean;
-  exhaustedReason?: string;
-} {
-  const {
-    stepsUsed,
-    maxSteps,
-    startTime,
-    maxMinutes,
-    pagesVisited,
-    maxPages,
-  } = params;
-
-  const minutesUsed = (Date.now() - startTime) / 60000;
-  const stepsRemaining = maxSteps - stepsUsed;
-  const minutesRemaining = maxMinutes - minutesUsed;
-  const pagesRemaining = maxPages - pagesVisited;
-
-  let isExhausted = false;
-  let exhaustedReason: string | undefined;
-
-  if (stepsRemaining <= 0) {
-    isExhausted = true;
-    exhaustedReason = "maxSteps limit reached";
-  } else if (minutesRemaining <= 0) {
-    isExhausted = true;
-    exhaustedReason = "maxMinutes timeout reached";
-  } else if (pagesRemaining <= 0) {
-    isExhausted = true;
-    exhaustedReason = "maxPages limit reached";
-  }
-
-  return {
-    stepsUsed,
-    stepsRemaining: Math.max(0, stepsRemaining),
-    minutesUsed: Math.round(minutesUsed * 10) / 10,
-    minutesRemaining: Math.max(0, Math.round(minutesRemaining * 10) / 10),
-    pagesVisited,
-    pagesRemaining: Math.max(0, pagesRemaining),
-    isExhausted,
-    exhaustedReason,
-  };
-}

package/src/progress/types.ts

@@ -1,25 +0,0 @@
-export interface ProgressInfo {
-  progressToken: string | number;
-  progress: number;
-  total?: number;
-  message?: string;
-  budgetStatus?: {
-    stepsUsed: number;
-    stepsRemaining: number;
-    minutesUsed: number;
-    minutesRemaining: number;
-    pagesVisited: number;
-    pagesRemaining: number;
-  };
-}
-
-export interface ProgressNotification {
-  method: "notifications/progress";
-  params: {
-    progressToken: string | number;
-    progress: number;
-    total?: number;
-  };
-}
-
-export type CancelledCallback = (requestId: string) => void;