chatccc 0.2.230 → 0.2.231

package/src/__tests__/agent-reload-config-rpc.test.ts

@@ -1,99 +1,99 @@
-import { Readable } from "node:stream";
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  AGENT_RELOAD_CONFIG_PATH,
-  handleAgentReloadConfigRequest,
-} from "../agent-reload-config-rpc.ts";
-
-function request(path = AGENT_RELOAD_CONFIG_PATH, method = "POST"): Readable & {
-  url?: string;
-  method?: string;
-  headers: Record<string, string>;
-} {
-  const req = Readable.from([]) as Readable & {
-    url?: string;
-    method?: string;
-    headers: Record<string, string>;
-  };
-  req.url = path;
-  req.method = method;
-  req.headers = {};
-  return req;
-}
-
-function response() {
-  const res = {
-    statusCode: 0,
-    headers: {} as Record<string, string>,
-    body: "",
-    writeHead(status: number, headers: Record<string, string>) {
-      this.statusCode = status;
-      this.headers = headers;
-      return this;
-    },
-    end(chunk?: string) {
-      this.body += chunk ?? "";
-      return this;
-    },
-  };
-  return res;
-}
-
-describe("agent reload config RPC", () => {
-  it("reloads runtime config for POST requests", async () => {
-    const reload = vi.fn(async () => ({
-      configPath: "C:\\Users\\me\\.chatccc\\config.json",
-      defaultAgent: "codex" as const,
-      reloadedAt: "2026-07-02T05:00:00.000Z",
-    }));
-    const res = response();
-
-    await expect(handleAgentReloadConfigRequest(request() as never, res as never, reload)).resolves.toBe(true);
-
-    expect(reload).toHaveBeenCalledWith("agent-reload-api");
-    expect(res.statusCode).toBe(200);
-    expect(JSON.parse(res.body)).toEqual({
-      ok: true,
-      configPath: "C:\\Users\\me\\.chatccc\\config.json",
-      defaultAgent: "codex",
-      reloadedAt: "2026-07-02T05:00:00.000Z",
-    });
-  });
-
-  it("rejects non-POST requests without reloading", async () => {
-    const reload = vi.fn();
-    const res = response();
-
-    await expect(handleAgentReloadConfigRequest(request(AGENT_RELOAD_CONFIG_PATH, "GET") as never, res as never, reload)).resolves.toBe(true);
-
-    expect(reload).not.toHaveBeenCalled();
-    expect(res.statusCode).toBe(405);
-    expect(JSON.parse(res.body)).toMatchObject({ ok: false, error: "Method not allowed" });
-  });
-
-  it("does not handle other paths", async () => {
-    const res = response();
-
-    await expect(handleAgentReloadConfigRequest(request("/api/other") as never, res as never, vi.fn())).resolves.toBe(false);
-
-    expect(res.body).toBe("");
-  });
-
-  it("returns a visible error when reload fails", async () => {
-    const res = response();
-
-    await expect(
-      handleAgentReloadConfigRequest(
-        request() as never,
-        res as never,
-        vi.fn(async () => {
-          throw new Error("bad config");
-        }),
-      ),
-    ).resolves.toBe(true);
-
-    expect(res.statusCode).toBe(500);
-    expect(JSON.parse(res.body)).toEqual({ ok: false, error: "bad config" });
-  });
-});
+import { Readable } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  AGENT_RELOAD_CONFIG_PATH,
+  handleAgentReloadConfigRequest,
+} from "../agent-reload-config-rpc.ts";
+
+function request(path = AGENT_RELOAD_CONFIG_PATH, method = "POST"): Readable & {
+  url?: string;
+  method?: string;
+  headers: Record<string, string>;
+} {
+  const req = Readable.from([]) as Readable & {
+    url?: string;
+    method?: string;
+    headers: Record<string, string>;
+  };
+  req.url = path;
+  req.method = method;
+  req.headers = {};
+  return req;
+}
+
+function response() {
+  const res = {
+    statusCode: 0,
+    headers: {} as Record<string, string>,
+    body: "",
+    writeHead(status: number, headers: Record<string, string>) {
+      this.statusCode = status;
+      this.headers = headers;
+      return this;
+    },
+    end(chunk?: string) {
+      this.body += chunk ?? "";
+      return this;
+    },
+  };
+  return res;
+}
+
+describe("agent reload config RPC", () => {
+  it("reloads runtime config for POST requests", async () => {
+    const reload = vi.fn(async () => ({
+      configPath: "C:\\Users\\me\\.chatccc\\config.json",
+      defaultAgent: "codex" as const,
+      reloadedAt: "2026-07-02T05:00:00.000Z",
+    }));
+    const res = response();
+
+    await expect(handleAgentReloadConfigRequest(request() as never, res as never, reload)).resolves.toBe(true);
+
+    expect(reload).toHaveBeenCalledWith("agent-reload-api");
+    expect(res.statusCode).toBe(200);
+    expect(JSON.parse(res.body)).toEqual({
+      ok: true,
+      configPath: "C:\\Users\\me\\.chatccc\\config.json",
+      defaultAgent: "codex",
+      reloadedAt: "2026-07-02T05:00:00.000Z",
+    });
+  });
+
+  it("rejects non-POST requests without reloading", async () => {
+    const reload = vi.fn();
+    const res = response();
+
+    await expect(handleAgentReloadConfigRequest(request(AGENT_RELOAD_CONFIG_PATH, "GET") as never, res as never, reload)).resolves.toBe(true);
+
+    expect(reload).not.toHaveBeenCalled();
+    expect(res.statusCode).toBe(405);
+    expect(JSON.parse(res.body)).toMatchObject({ ok: false, error: "Method not allowed" });
+  });
+
+  it("does not handle other paths", async () => {
+    const res = response();
+
+    await expect(handleAgentReloadConfigRequest(request("/api/other") as never, res as never, vi.fn())).resolves.toBe(false);
+
+    expect(res.body).toBe("");
+  });
+
+  it("returns a visible error when reload fails", async () => {
+    const res = response();
+
+    await expect(
+      handleAgentReloadConfigRequest(
+        request() as never,
+        res as never,
+        vi.fn(async () => {
+          throw new Error("bad config");
+        }),
+      ),
+    ).resolves.toBe(true);
+
+    expect(res.statusCode).toBe(500);
+    expect(JSON.parse(res.body)).toEqual({ ok: false, error: "bad config" });
+  });
+});

package/src/__tests__/builtin-chat-session.test.ts

@@ -52,6 +52,7 @@ afterEach(() => {
   rawLogWriteLineMock.mockReset();
   rawLogCloseMock.mockReset();
   config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+  vi.useRealTimers();
 });
 
 describe("ChatSession context management", () => {
@@ -223,10 +224,49 @@ describe("ChatSession context management", () => {
         expect.objectContaining({ role: "user", content: "new question" }),
       ]),
     }));
-    expect(events).toContainEqual({ type: "compact", compactedMessages: 2 });
+    expect(events.slice(0, 3)).toEqual([
+      { type: "status", phase: "compacting" },
+      { type: "compact", compactedMessages: 2 },
+      { type: "status", phase: "generating" },
+    ]);
     expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
   });
 
+  it("times out context compaction independently before reply generation", async () => {
+    vi.useFakeTimers();
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "deepccc-session-compaction-timeout-"));
+    const seed = new ChatSession(
+      { apiKey: "sk-test" },
+      { persist: true, contextDir: dir, sessionId: "timeout", compactAtTokens: 10_000 },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
+    await collect(seed.chat("old question"));
+
+    generateTextMock.mockImplementationOnce(({ abortSignal }: { abortSignal: AbortSignal }) =>
+      new Promise((_resolve, reject) => {
+        abortSignal.addEventListener("abort", () => reject(abortSignal.reason), { once: true });
+      }));
+    const restored = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "timeout",
+        compactAtTokens: 1,
+        keepRecentMessages: 1,
+        compactionTimeoutMs: 100,
+      },
+    );
+
+    const result = collect(restored.chat("new question"));
+    const timeoutAssertion = expect(result).rejects.toThrow("Context compaction timed out");
+    await vi.waitFor(() => expect(generateTextMock).toHaveBeenCalledOnce());
+    await vi.advanceTimersByTimeAsync(101);
+    await timeoutAssertion;
+    expect(streamTextMock).toHaveBeenCalledTimes(1);
+  });
+
   it("streams tool calls and tool results from fullStream", async () => {
     const { ChatSession } = await import("../builtin/index.ts");
     const dir = await mkdtemp(join(tmpdir(), "deepccc-session-tools-"));
@@ -265,6 +305,30 @@ describe("ChatSession context management", () => {
     expect(events).toContainEqual({ type: "text", text: "done", accumulated: "done" });
   });
 
+  it("caps the total persisted tool transcript for a turn", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "deepccc-session-tool-cap-"));
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { persist: true, contextDir: dir, sessionId: "tool-cap" },
+    );
+    const parts = Array.from({ length: 12 }, (_, index) => ({
+      type: "tool-result",
+      toolCallId: `call-${index}`,
+      toolName: "read_file",
+      output: { content: "x".repeat(8_000) },
+    }));
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(...parts, { type: "text-delta", text: "done" }),
+    });
+
+    await collect(session.chat("read many files"));
+
+    const persisted = session.history.at(-1)?.content ?? "";
+    expect(persisted.length).toBeLessThan(40_000);
+    expect(persisted).toContain("tool transcript truncated");
+  });
+
   it("writes raw DeepCCC fullStream parts when raw stream logs are enabled", async () => {
     const { ChatSession } = await import("../builtin/index.ts");
     config.rawStreamLogs = {

package/src/__tests__/builtin-cli-json.test.ts

@@ -1,39 +1,39 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-import { describe, expect, it } from "vitest";
-
-const execFileAsync = promisify(execFile);
-
-describe("builtin cli --stream-json", () => {
-  it("writes only JSON lines to stdout when startup fails", async () => {
-    let caught: unknown;
-    try {
-      await execFileAsync(process.execPath, [
-        "bin/cccagent.mjs",
-        "--stream-json",
-        "--prompt",
-        "hello",
-        "--api-key",
-        "",
-      ], {
-        cwd: process.cwd(),
-        timeout: 10_000,
-        windowsHide: true,
-      });
-    } catch (err) {
-      caught = err;
-    }
-
-    expect(caught).toMatchObject({ code: 1 });
-    const stdout = (caught as { stdout?: string }).stdout ?? "";
-    const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
-    expect(lines.length).toBeGreaterThan(0);
-    for (const line of lines) {
-      expect(() => JSON.parse(line)).not.toThrow();
-    }
-    expect(JSON.parse(lines.at(-1)!)).toEqual(expect.objectContaining({
-      type: "error",
-    }));
-  });
-});
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import { describe, expect, it } from "vitest";
+
+const execFileAsync = promisify(execFile);
+
+describe("builtin cli --stream-json", () => {
+  it("writes only JSON lines to stdout when startup fails", async () => {
+    let caught: unknown;
+    try {
+      await execFileAsync(process.execPath, [
+        "bin/cccagent.mjs",
+        "--stream-json",
+        "--prompt",
+        "hello",
+        "--api-key",
+        "",
+      ], {
+        cwd: process.cwd(),
+        timeout: 10_000,
+        windowsHide: true,
+      });
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toMatchObject({ code: 1 });
+    const stdout = (caught as { stdout?: string }).stdout ?? "";
+    const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
+    expect(lines.length).toBeGreaterThan(0);
+    for (const line of lines) {
+      expect(() => JSON.parse(line)).not.toThrow();
+    }
+    expect(JSON.parse(lines.at(-1)!)).toEqual(expect.objectContaining({
+      type: "error",
+    }));
+  });
+});

package/src/__tests__/builtin-config.test.ts

@@ -1,26 +1,26 @@
-import { afterEach, describe, expect, it } from "vitest";
-
-import { ChatSession } from "../builtin/index.ts";
-import { config } from "../builtin/config.ts";
-
-const originalDeepSeekApiKey = process.env.DEEPSEEK_API_KEY;
-const originalDeepCccApiKey = config.apiKey;
-
-afterEach(() => {
-  if (originalDeepSeekApiKey === undefined) {
-    delete process.env.DEEPSEEK_API_KEY;
-  } else {
-    process.env.DEEPSEEK_API_KEY = originalDeepSeekApiKey;
-  }
-  config.apiKey = originalDeepCccApiKey;
-});
-
-describe("builtin ChatSession config", () => {
-  it("uses the builtin ~/.deepccc config when no apiKey is passed", () => {
-    expect(() => new ChatSession()).not.toThrow();
-  });
-
-  it("allows constructor parameters to override config defaults", () => {
-    expect(() => new ChatSession({ apiKey: "sk-test" })).not.toThrow();
-  });
-});
+import { afterEach, describe, expect, it } from "vitest";
+
+import { ChatSession } from "../builtin/index.ts";
+import { config } from "../builtin/config.ts";
+
+const originalDeepSeekApiKey = process.env.DEEPSEEK_API_KEY;
+const originalDeepCccApiKey = config.apiKey;
+
+afterEach(() => {
+  if (originalDeepSeekApiKey === undefined) {
+    delete process.env.DEEPSEEK_API_KEY;
+  } else {
+    process.env.DEEPSEEK_API_KEY = originalDeepSeekApiKey;
+  }
+  config.apiKey = originalDeepCccApiKey;
+});
+
+describe("builtin ChatSession config", () => {
+  it("uses the builtin ~/.deepccc config when no apiKey is passed", () => {
+    expect(() => new ChatSession()).not.toThrow();
+  });
+
+  it("allows constructor parameters to override config defaults", () => {
+    expect(() => new ChatSession({ apiKey: "sk-test" })).not.toThrow();
+  });
+});