@goondan/openharness-base 0.1.8 → 0.1.9

package/src/__tests__/basic-system-prompt.test.ts

@@ -1,186 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { BasicSystemPrompt } from "../extensions/basic-system-prompt.js";
-import type {
-  ExtensionApi,
-  TurnMiddleware,
-  TurnContext,
-  TurnResult,
-  ConversationState,
-  Message,
-  MessageEvent,
-} from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMockConversationState(): ConversationState & { emitted: MessageEvent[] } {
-  const emitted: MessageEvent[] = [];
-  const messages: Message[] = [];
-  return {
-    messages,
-    events: [],
-    emitted,
-    emit: vi.fn((event: MessageEvent) => {
-      emitted.push(event);
-      if (event.type === "append") {
-        messages.push(event.message);
-      }
-    }),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(conversation: ConversationState): {
-  api: ExtensionApi;
-  registeredMiddleware: Array<{ level: string; handler: TurnMiddleware; options?: { priority?: number } }>;
-} {
-  const registeredMiddleware: Array<{ level: string; handler: TurnMiddleware; options?: { priority?: number } }> = [];
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn((level: string, handler: TurnMiddleware, options?: { priority?: number }) => {
-        registeredMiddleware.push({ level, handler, options });
-      }) as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn(),
-      remove: vi.fn(),
-      list: vi.fn(() => []),
-    },
-    on: vi.fn(),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, registeredMiddleware };
-}
-
-function makeTurnContext(conversation: ConversationState): TurnContext {
-  return {
-    turnId: "turn-1",
-    agentName: "test-agent",
-    conversationId: "conv-1",
-    conversation,
-    abortSignal: new AbortController().signal,
-    input: {
-      name: "test-event",
-      content: [{ type: "text", text: "hello" }],
-      properties: {},
-      source: {
-        connector: "test-connector",
-        connectionName: "test",
-        receivedAt: new Date().toISOString(),
-      },
-    },
-    llm: { chat: vi.fn().mockResolvedValue({ text: "mock" }) },
-  };
-}
-
-const stubTurnResult: TurnResult = {
-  turnId: "turn-1",
-  agentName: "test-agent",
-  conversationId: "conv-1",
-  status: "completed",
-  steps: [],
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("BasicSystemPrompt", () => {
-  it("creates an Extension with name 'basic-system-prompt'", () => {
-    const ext = BasicSystemPrompt("You are helpful.");
-    expect(ext.name).toBe("basic-system-prompt");
-  });
-
-  it("register() calls api.pipeline.register with level 'turn'", () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = BasicSystemPrompt("You are helpful.");
-    ext.register(api);
-
-    expect(api.pipeline.register).toHaveBeenCalledOnce();
-    expect(registeredMiddleware).toHaveLength(1);
-    expect(registeredMiddleware[0].level).toBe("turn");
-    expect(typeof registeredMiddleware[0].handler).toBe("function");
-  });
-
-  it("registers turn middleware with priority 10 (high priority)", () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = BasicSystemPrompt("You are helpful.");
-    ext.register(api);
-
-    expect(registeredMiddleware[0].options?.priority).toBe(10);
-  });
-
-  it("middleware appends a system message and calls next()", async () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = BasicSystemPrompt("You are helpful.");
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeTurnContext(conversation);
-    const next = vi.fn(async () => stubTurnResult);
-
-    const result = await middleware(ctx, next);
-
-    expect(next).toHaveBeenCalledOnce();
-    expect(result).toBe(stubTurnResult);
-
-    // Verify system message was emitted
-    expect(conversation.emit).toHaveBeenCalledOnce();
-    const emittedEvent = conversation.emitted[0];
-    expect(emittedEvent.type).toBe("append");
-    if (emittedEvent.type === "append") {
-      expect(emittedEvent.message.id).toBe("sys-basic-system-prompt");
-      expect(emittedEvent.message.data.role).toBe("system");
-      expect(emittedEvent.message.data.content).toBe("You are helpful.");
-      expect(emittedEvent.message.metadata?.__createdBy).toBe("basic-system-prompt");
-    }
-  });
-
-  it("does not duplicate the system message on subsequent turns", async () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = BasicSystemPrompt("You are helpful.");
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const next = vi.fn(async () => stubTurnResult);
-
-    // First turn — should append
-    const ctx1 = makeTurnContext(conversation);
-    await middleware(ctx1, next);
-    expect(conversation.emitted).toHaveLength(1);
-
-    // Second turn — system message already in conversation.messages, should skip
-    const ctx2 = makeTurnContext(conversation);
-    await middleware(ctx2, next);
-    expect(conversation.emitted).toHaveLength(1); // still 1, no new append
-
-    // Third turn — still no duplication
-    const ctx3 = makeTurnContext(conversation);
-    await middleware(ctx3, next);
-    expect(conversation.emitted).toHaveLength(1);
-
-    // next() should have been called every turn
-    expect(next).toHaveBeenCalledTimes(3);
-  });
-});

package/src/__tests__/compaction-summarize.test.ts

@@ -1,282 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { CompactionSummarize } from "../extensions/compaction-summarize.js";
-import type {
-  ExtensionApi,
-  StepMiddleware,
-  StepContext,
-  StepResult,
-  ConversationState,
-  Message,
-  MessageEvent,
-} from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMessages(count: number): Message[] {
-  return Array.from({ length: count }, (_, i) => ({
-    id: `msg-${i}`,
-    data: {
-      role: "user" as const,
-      content: `Message ${i}`,
-    },
-  }));
-}
-
-function makeMockConversationState(
-  messages: Message[],
-): ConversationState & { emitted: MessageEvent[] } {
-  const emitted: MessageEvent[] = [];
-  return {
-    messages,
-    events: [],
-    emitted,
-    emit: vi.fn((event: MessageEvent) => {
-      emitted.push(event);
-    }),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(conversation: ConversationState): {
-  api: ExtensionApi;
-  registeredMiddleware: Array<{
-    level: string;
-    handler: StepMiddleware;
-    options?: { priority?: number };
-  }>;
-} {
-  const registeredMiddleware: Array<{
-    level: string;
-    handler: StepMiddleware;
-    options?: { priority?: number };
-  }> = [];
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn(
-        (level: string, handler: StepMiddleware, options?: { priority?: number }) => {
-          registeredMiddleware.push({ level, handler, options });
-        },
-      ) as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn(),
-      remove: vi.fn(),
-      list: vi.fn(() => []),
-    },
-    on: vi.fn(),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, registeredMiddleware };
-}
-
-function makeMockLlmClient() {
-  return {
-    chat: vi.fn().mockResolvedValue({ text: "LLM-generated summary of the conversation." }),
-  };
-}
-
-function makeStepContext(conversation: ConversationState): StepContext {
-  return {
-    turnId: "turn-1",
-    agentName: "test-agent",
-    conversationId: "conv-1",
-    conversation,
-    stepNumber: 1,
-    abortSignal: new AbortController().signal,
-    input: {
-      name: "test-event",
-      content: [{ type: "text", text: "hello" }],
-      properties: {},
-      source: {
-        connector: "test-connector",
-        connectionName: "test",
-        receivedAt: new Date().toISOString(),
-      },
-    },
-    llm: makeMockLlmClient(),
-  };
-}
-
-const stubStepResult: StepResult = {
-  toolCalls: [],
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("CompactionSummarize", () => {
-  it("creates an Extension with name 'compaction-summarize'", () => {
-    const ext = CompactionSummarize({ threshold: 10 });
-    expect(ext.name).toBe("compaction-summarize");
-  });
-
-  it("registers step middleware via api.pipeline.register", () => {
-    const conversation = makeMockConversationState([]);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = CompactionSummarize({ threshold: 10 });
-    ext.register(api);
-
-    expect(api.pipeline.register).toHaveBeenCalledOnce();
-    expect(registeredMiddleware[0].level).toBe("step");
-  });
-
-  it("does NOT compact when messages are below threshold", async () => {
-    const messages = makeMessages(5);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = CompactionSummarize({ threshold: 10 });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    expect(conversation.emit).not.toHaveBeenCalled();
-    expect(next).toHaveBeenCalledOnce();
-  });
-
-  it("compacts when messages exceed threshold", async () => {
-    const messages = makeMessages(12);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = CompactionSummarize({ threshold: 10 });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted;
-
-    // keepCount = floor(10/2) = 5, removeCount = 12 - 5 = 7
-    // Should have 7 remove events + 1 append event
-    const removeEvents = emitted.filter((e) => e.type === "remove");
-    const appendEvents = emitted.filter((e) => e.type === "append");
-
-    expect(removeEvents).toHaveLength(7);
-    expect(appendEvents).toHaveLength(1);
-
-    // The appended message should be a system summary
-    const appendEvent = appendEvents[0];
-    if (appendEvent.type === "append") {
-      expect(appendEvent.message.data.role).toBe("system");
-      expect(appendEvent.message.data.content).toContain("[Summary of earlier conversation]:");
-      expect(appendEvent.message.metadata?.__createdBy).toBe("compaction-summarize");
-    }
-
-    expect(next).toHaveBeenCalledOnce();
-  });
-
-  it("removes the oldest messages (not the newest)", async () => {
-    const messages = makeMessages(12);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = CompactionSummarize({ threshold: 10 });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted;
-    const removeEvents = emitted.filter(
-      (e): e is Extract<typeof e, { type: "remove" }> => e.type === "remove",
-    );
-
-    // Should remove msg-0 through msg-6 (the oldest 7)
-    const removedIds = removeEvents.map((e) => e.messageId);
-    expect(removedIds).toContain("msg-0");
-    expect(removedIds).toContain("msg-6");
-    expect(removedIds).not.toContain("msg-7");
-    expect(removedIds).not.toContain("msg-11");
-  });
-
-  it("summary content includes text from removed messages", async () => {
-    const messages = makeMessages(12);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const ext = CompactionSummarize({ threshold: 10 });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    // Verify LLM was called for summarization
-    expect(ctx.llm.chat).toHaveBeenCalledOnce();
-
-    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted;
-    const appendEvent = emitted.find((e) => e.type === "append");
-    if (appendEvent && appendEvent.type === "append") {
-      const content = appendEvent.message.data.content as string;
-      // Should include the LLM-generated summary
-      expect(content).toContain("LLM-generated summary of the conversation.");
-    }
-  });
-
-  it("uses custom summarizer when provided", async () => {
-    const messages = makeMessages(12);
-    const conversation = makeMockConversationState(messages);
-    const { api, registeredMiddleware } = makeMockApi(conversation);
-
-    const summarizer = vi.fn(async (msgs: Message[]) => {
-      return `Custom summary of ${msgs.length} messages`;
-    });
-
-    const ext = CompactionSummarize({ threshold: 10, summarizer });
-    ext.register(api);
-
-    const middleware = registeredMiddleware[0].handler;
-    const ctx = makeStepContext(conversation);
-    const next = vi.fn(async () => stubStepResult);
-
-    await middleware(ctx, next);
-
-    // summarizer should have been called with the 7 removed messages
-    expect(summarizer).toHaveBeenCalledOnce();
-    expect(summarizer).toHaveBeenCalledWith(
-      expect.arrayContaining([
-        expect.objectContaining({ id: "msg-0" }),
-        expect.objectContaining({ id: "msg-6" }),
-      ]),
-    );
-    expect(summarizer.mock.calls[0][0]).toHaveLength(7);
-
-    const emitted = (conversation as ReturnType<typeof makeMockConversationState>).emitted;
-    const appendEvent = emitted.find((e) => e.type === "append");
-    if (appendEvent && appendEvent.type === "append") {
-      const content = appendEvent.message.data.content as string;
-      expect(content).toContain("Custom summary of 7 messages");
-    }
-
-    expect(next).toHaveBeenCalledOnce();
-  });
-});

package/src/__tests__/logging.test.ts

@@ -1,200 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { Logging } from "../extensions/logging.js";
-import type { ExtensionApi, ConversationState } from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMockConversationState(): ConversationState {
-  return {
-    messages: [],
-    events: [],
-    emit: vi.fn(),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(conversation: ConversationState): {
-  api: ExtensionApi;
-  eventListeners: Map<string, Array<(payload: unknown) => void>>;
-} {
-  const eventListeners = new Map<string, Array<(payload: unknown) => void>>();
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn() as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn(),
-      remove: vi.fn(),
-      list: vi.fn(() => []),
-    },
-    on: vi.fn((event: string, listener: (payload: unknown) => void) => {
-      if (!eventListeners.has(event)) {
-        eventListeners.set(event, []);
-      }
-      eventListeners.get(event)!.push(listener);
-    }),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, eventListeners };
-}
-
-function emit(
-  eventListeners: Map<string, Array<(payload: unknown) => void>>,
-  event: string,
-  payload: unknown,
-) {
-  eventListeners.get(event)?.forEach((l) => l(payload));
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("Logging", () => {
-  it("creates an Extension with name 'logging'", () => {
-    const ext = Logging();
-    expect(ext.name).toBe("logging");
-  });
-
-  it("subscribes to all core events on register", () => {
-    const conversation = makeMockConversationState();
-    const { api } = makeMockApi(conversation);
-
-    const ext = Logging();
-    ext.register(api);
-
-    expect(api.on).toHaveBeenCalledWith("turn.start", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("turn.done", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("turn.error", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("step.start", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("step.done", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("tool.start", expect.any(Function));
-    expect(api.on).toHaveBeenCalledWith("tool.done", expect.any(Function));
-  });
-
-  it("logs turn.start event with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "turn.start", { turnId: "t1" });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("turn.start");
-  });
-
-  it("logs turn.done event", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "turn.done", { turnId: "t1", status: "completed" });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("turn.done");
-  });
-
-  it("logs turn.error event", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "turn.error", { error: "oops" });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("turn.error");
-  });
-
-  it("uses console.log as default logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-
-    const ext = Logging();
-    ext.register(api);
-
-    emit(eventListeners, "turn.start", { turnId: "t1" });
-
-    expect(consoleSpy).toHaveBeenCalledOnce();
-    consoleSpy.mockRestore();
-  });
-
-  it("logs step.start event with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "step.start", { stepIndex: 0 });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("step.start");
-    expect(logger.mock.calls[0][0]).toContain("stepIndex");
-  });
-
-  it("logs step.done event with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "step.done", { stepIndex: 0, toolCallCount: 2 });
-
-    expect(logger).toHaveBeenCalledOnce();
-    expect(logger.mock.calls[0][0]).toContain("step.done");
-  });
-
-  it("logs tool.start and tool.done events with custom logger", () => {
-    const conversation = makeMockConversationState();
-    const { api, eventListeners } = makeMockApi(conversation);
-    const logger = vi.fn();
-
-    const ext = Logging({ logger });
-    ext.register(api);
-
-    emit(eventListeners, "tool.start", { toolName: "bash", toolCallId: "tc-1" });
-    emit(eventListeners, "tool.done", { toolName: "bash", toolCallId: "tc-1", result: { type: "text", text: "ok" } });
-
-    expect(logger).toHaveBeenCalledTimes(2);
-    expect(logger.mock.calls[0][0]).toContain("tool.start");
-    expect(logger.mock.calls[0][0]).toContain("bash");
-    expect(logger.mock.calls[1][0]).toContain("tool.done");
-  });
-
-  it("does NOT call pipeline.register (event-based, no middleware)", () => {
-    const conversation = makeMockConversationState();
-    const { api } = makeMockApi(conversation);
-
-    const ext = Logging();
-    ext.register(api);
-
-    expect(api.pipeline.register).not.toHaveBeenCalled();
-  });
-});