chatccc 0.2.231 → 0.2.232

package/src/__tests__/claude-raw-stream-log.test.ts

@@ -1,87 +1,87 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const resumeSessionMock = vi.hoisted(() => vi.fn());
-const createRawStreamLogMock = vi.hoisted(() => vi.fn());
-const rawLogWriteLineMock = vi.hoisted(() => vi.fn());
-const rawLogCloseMock = vi.hoisted(() => vi.fn());
-
-vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
-  getSessionInfo: vi.fn(),
-  unstable_v2_createSession: vi.fn(),
-  unstable_v2_resumeSession: resumeSessionMock,
-}));
-
-vi.mock("../adapters/raw-stream-log.ts", () => ({
-  createRawStreamLog: createRawStreamLogMock,
-}));
-
-import { config } from "../config.ts";
-import { createClaudeAdapter } from "../adapters/claude-adapter.ts";
-
-const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
-
-async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
-  const events: unknown[] = [];
-  for await (const event of iterable) events.push(event);
-  return events;
-}
-
-afterEach(() => {
-  resumeSessionMock.mockReset();
-  createRawStreamLogMock.mockReset();
-  rawLogWriteLineMock.mockReset();
-  rawLogCloseMock.mockReset();
-  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
-});
-
-describe("Claude raw stream logs", () => {
-  it("writes raw Claude SDK stream messages when enabled", async () => {
-    const rawMessages = [
-      { type: "system", subtype: "init", session_id: "sid-raw", cwd: "F:/project", model: "claude-test" },
-      { type: "assistant", message: { content: [{ type: "text", text: "hello" }] } },
-    ];
-    const session = {
-      send: vi.fn(async () => {}),
-      stream: async function* () {
-        for (const msg of rawMessages) yield msg;
-      },
-      close: vi.fn(),
-    };
-    resumeSessionMock.mockReturnValueOnce(session);
-    createRawStreamLogMock.mockResolvedValueOnce({
-      filePath: "claude.jsonl.gz",
-      writeLine: rawLogWriteLineMock,
-      close: rawLogCloseMock,
-    });
-    config.rawStreamLogs.claude = {
-      enabled: true,
-      maxBytesPerTurn: 4096,
-      retentionDays: 5,
-      keepCompleted: false,
-    };
-
-    const adapter = createClaudeAdapter({
-      model: "claude-test",
-      effort: "high",
-      isEmpty: (value) => value.trim() === "",
-    });
-    const events = await collect(adapter.prompt("sid-raw", "hi", "F:/project"));
-
-    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
-      enabled: true,
-      tool: "claude",
-      sessionId: "sid-raw",
-      label: "prompt",
-      maxBytesPerTurn: 4096,
-      retentionDays: 5,
-    }));
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(rawMessages[0]));
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(rawMessages[1]));
-    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: false });
-    expect(session.close).toHaveBeenCalledOnce();
-    expect(events).toContainEqual({
-      type: "assistant",
-      blocks: [{ type: "text", text: "hello" }],
-    });
-  });
-});
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const resumeSessionMock = vi.hoisted(() => vi.fn());
+const createRawStreamLogMock = vi.hoisted(() => vi.fn());
+const rawLogWriteLineMock = vi.hoisted(() => vi.fn());
+const rawLogCloseMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  getSessionInfo: vi.fn(),
+  unstable_v2_createSession: vi.fn(),
+  unstable_v2_resumeSession: resumeSessionMock,
+}));
+
+vi.mock("../adapters/raw-stream-log.ts", () => ({
+  createRawStreamLog: createRawStreamLogMock,
+}));
+
+import { config } from "../config.ts";
+import { createClaudeAdapter } from "../adapters/claude-adapter.ts";
+
+const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
+
+async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
+  const events: unknown[] = [];
+  for await (const event of iterable) events.push(event);
+  return events;
+}
+
+afterEach(() => {
+  resumeSessionMock.mockReset();
+  createRawStreamLogMock.mockReset();
+  rawLogWriteLineMock.mockReset();
+  rawLogCloseMock.mockReset();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+});
+
+describe("Claude raw stream logs", () => {
+  it("writes raw Claude SDK stream messages when enabled", async () => {
+    const rawMessages = [
+      { type: "system", subtype: "init", session_id: "sid-raw", cwd: "F:/project", model: "claude-test" },
+      { type: "assistant", message: { content: [{ type: "text", text: "hello" }] } },
+    ];
+    const session = {
+      send: vi.fn(async () => {}),
+      stream: async function* () {
+        for (const msg of rawMessages) yield msg;
+      },
+      close: vi.fn(),
+    };
+    resumeSessionMock.mockReturnValueOnce(session);
+    createRawStreamLogMock.mockResolvedValueOnce({
+      filePath: "claude.jsonl.gz",
+      writeLine: rawLogWriteLineMock,
+      close: rawLogCloseMock,
+    });
+    config.rawStreamLogs.claude = {
+      enabled: true,
+      maxBytesPerTurn: 4096,
+      retentionDays: 5,
+      keepCompleted: false,
+    };
+
+    const adapter = createClaudeAdapter({
+      model: "claude-test",
+      effort: "high",
+      isEmpty: (value) => value.trim() === "",
+    });
+    const events = await collect(adapter.prompt("sid-raw", "hi", "F:/project"));
+
+    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
+      enabled: true,
+      tool: "claude",
+      sessionId: "sid-raw",
+      label: "prompt",
+      maxBytesPerTurn: 4096,
+      retentionDays: 5,
+    }));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(rawMessages[0]));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(rawMessages[1]));
+    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: false });
+    expect(session.close).toHaveBeenCalledOnce();
+    expect(events).toContainEqual({
+      type: "assistant",
+      blocks: [{ type: "text", text: "hello" }],
+    });
+  });
+});

package/src/__tests__/codex-adapter.test.ts

@@ -2,9 +2,9 @@ import { describe, it, expect } from "vitest";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import {
-  buildCodexInvocationArgs,
-  normalizeCodexMessage,
+import {
+  buildCodexInvocationArgs,
+  normalizeCodexMessage,
   createCodexAdapter,
   type CreateCodexAdapterOptions,
 } from "../adapters/codex-adapter.ts";
@@ -15,21 +15,21 @@ import {
 } from "../adapters/codex-session-meta-store.ts";
 import { accumulateBlockContent, pickFinalReply, type AccumulatorState } from "../session.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("buildCodexInvocationArgs", () => {
-  it("forces the priority service tier when Fast mode is on", () => {
-    expect(buildCodexInvocationArgs(["exec", "--json"], "", "", true)).toContain(
-      'service_tier="fast"',
-    );
-  });
-
-  it("forces the standard service tier when Fast mode is off", () => {
-    const args = buildCodexInvocationArgs(["exec", "--json"], "", "", false);
-    expect(args).toContain('service_tier="default"');
-    expect(args).not.toContain('service_tier="fast"');
-  });
-});
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+describe("buildCodexInvocationArgs", () => {
+  it("forces the priority service tier when Fast mode is on", () => {
+    expect(buildCodexInvocationArgs(["exec", "--json"], "", "", true)).toContain(
+      'service_tier="fast"',
+    );
+  });
+
+  it("forces the standard service tier when Fast mode is off", () => {
+    const args = buildCodexInvocationArgs(["exec", "--json"], "", "", false);
+    expect(args).toContain('service_tier="default"');
+    expect(args).not.toContain('service_tier="fast"');
+  });
+});
 
 function readFixture(name: string): unknown[] {
   const raw = readFileSync(join(__dirname, "fixtures", name), "utf-8");
@@ -71,16 +71,16 @@ function createInMemoryMetaStore(
 // ---------------------------------------------------------------------------
 
 describe("normalizeCodexMessage", () => {
-  it("normalizes agent_message into assistant text block", () => {
-    const result = normalizeCodexMessage({
-      type: "item.completed",
-      item: { id: "item_0", type: "agent_message", text: "hello" },
+  it("normalizes agent_message into assistant text block", () => {
+    const result = normalizeCodexMessage({
+      type: "item.completed",
+      item: { id: "item_0", type: "agent_message", text: "hello" },
     });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([{ type: "text", text: "hello" }]);
-    expect(result!.isFinalResponse).toBeUndefined();
-  });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([{ type: "text", text: "hello" }]);
+    expect(result!.isFinalResponse).toBeUndefined();
+  });
 
   it("normalizes command_execution start into tool_use block", () => {
     const result = normalizeCodexMessage({
@@ -92,12 +92,12 @@ describe("normalizeCodexMessage", () => {
         status: "in_progress",
       },
     });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([
-      { type: "tool_use", id: "item_0", name: "Bash", input: { command: "powershell.exe -Command ls" } },
-    ]);
-  });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", id: "item_0", name: "Bash", input: { command: "powershell.exe -Command ls" } },
+    ]);
+  });
 
   it("normalizes command_execution completion as tool_result (success)", () => {
     const result = normalizeCodexMessage({
@@ -158,17 +158,17 @@ describe("normalizeCodexMessage", () => {
     expect(normalizeCodexMessage({ type: "turn.started" })).toBeNull();
   });
 
-  it("marks turn.completed as the authoritative final response", () => {
-    expect(
-      normalizeCodexMessage({
-        type: "turn.completed",
-        usage: { input_tokens: 100, output_tokens: 50 },
-      }),
-    ).toEqual({
-      type: "assistant",
-      blocks: [],
-      isFinalResponse: true,
-    });
+  it("marks turn.completed as the authoritative final response", () => {
+    expect(
+      normalizeCodexMessage({
+        type: "turn.completed",
+        usage: { input_tokens: 100, output_tokens: 50 },
+      }),
+    ).toEqual({
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    });
   });
 
   it("returns null for unknown event types", () => {
@@ -244,7 +244,7 @@ describe("Codex stream fixtures", () => {
     expect(state.accumulatedContent).toContain("tool_test");
   });
 
-  it("with tool: 普通输出不标终态，只有 turn.completed 标记终态", () => {
+  it("with tool: 普通输出不标终态，只有 turn.completed 标记终态", () => {
     const lines = readFixture("codex_with_tool.jsonl");
     const messages: UnifiedStreamMessage[] = [];
     for (const raw of lines) {
@@ -254,18 +254,18 @@ describe("Codex stream fixtures", () => {
       if (normalized) messages.push(normalized);
     }
 
-    // 应有: tool_use + tool_result + text + turn.completed = 4 条消息
-    expect(messages.length).toBe(4);
-    expect(messages[0].blocks[0].type).toBe("tool_use");
-    expect(messages[1].blocks[0].type).toBe("tool_result");
-    expect(messages[2].blocks[0].type).toBe("text");
-    expect(messages[2].isFinalResponse).toBeUndefined();
-    expect(messages[3]).toEqual({
-      type: "assistant",
-      blocks: [],
-      isFinalResponse: true,
-    });
-  });
+    // 应有: tool_use + tool_result + text + turn.completed = 4 条消息
+    expect(messages.length).toBe(4);
+    expect(messages[0].blocks[0].type).toBe("tool_use");
+    expect(messages[1].blocks[0].type).toBe("tool_result");
+    expect(messages[2].blocks[0].type).toBe("text");
+    expect(messages[2].isFinalResponse).toBeUndefined();
+    expect(messages[3]).toEqual({
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -328,4 +328,4 @@ describe("createCodexAdapter", () => {
     });
     expect(await adapter.getSessionInfo("sid-C")).toBeUndefined();
   });
-});
+});