chatccc 0.2.196 → 0.2.197

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

@@ -1,181 +1,277 @@
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { config } from "../config.ts";
-
-const streamTextMock = vi.fn();
-const generateTextMock = vi.fn();
-const createRawStreamLogMock = vi.fn();
-const rawLogWriteLineMock = vi.fn();
-const rawLogCloseMock = vi.fn();
-const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
-
-vi.mock("@ai-sdk/openai-compatible", () => ({
-  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("ai", () => ({
-  streamText: streamTextMock,
-  generateText: generateTextMock,
-  stepCountIs: vi.fn((count: number) => ({ count })),
-  jsonSchema: vi.fn((schema: unknown) => schema),
-  tool: vi.fn((definition: unknown) => definition),
-}));
-
-vi.mock("../adapters/raw-stream-log.ts", () => ({
-  createRawStreamLog: createRawStreamLogMock,
-}));
-
-async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
-  const events: unknown[] = [];
-  for await (const event of iterable) events.push(event);
-  return events;
-}
-
-async function* textStream(...chunks: string[]): AsyncIterable<string> {
-  for (const chunk of chunks) yield chunk;
-}
-
-async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
-  for (const part of parts) yield part;
-}
-
-afterEach(() => {
-  streamTextMock.mockReset();
-  generateTextMock.mockReset();
-  createRawStreamLogMock.mockReset();
-  rawLogWriteLineMock.mockReset();
-  rawLogCloseMock.mockReset();
-  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
-});
-
-describe("ChatSession context management", () => {
-  it("loads persisted context, compacts older messages, and persists the new assistant reply", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-context-"));
-
-    const seed = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        persist: true,
-        contextDir: dir,
-        sessionId: "integration",
-        compactAtTokens: 10_000,
-      },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
-    await collect(seed.chat("old question"));
-
-    generateTextMock.mockResolvedValueOnce({ text: "## 当前任务状态\n- 旧问题已总结" });
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("new answer") });
-
-    const restored = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        persist: true,
-        contextDir: dir,
-        sessionId: "integration",
-        compactAtTokens: 1,
-        keepRecentMessages: 1,
-      },
-    );
-    const events = await collect(restored.chat("new question"));
-
-    expect(generateTextMock).toHaveBeenCalledOnce();
-    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
-      messages: expect.arrayContaining([
-        expect.objectContaining({ content: expect.stringContaining("旧问题已总结") }),
-        expect.objectContaining({ role: "user", content: "new question" }),
-      ]),
-    }));
-    expect(events).toContainEqual({ type: "compact", compactedMessages: 2 });
-    expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
-  });
-
-  it("streams tool calls and tool results from fullStream", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-tools-"));
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        persist: true,
-        contextDir: dir,
-        sessionId: "tools",
-      },
-    );
-
-    streamTextMock.mockReturnValueOnce({
-      fullStream: fullStream(
-        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "package.json" } },
-        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "{}" } },
-        { type: "text-delta", text: "done" },
-      ),
-    });
-
-    const events = await collect(session.chat("read package"));
-
-    expect(events).toContainEqual({
-      type: "tool_use",
-      id: "call-1",
-      name: "read_file",
-      input: { path: "package.json" },
-    });
-    expect(events).toContainEqual({
-      type: "tool_result",
-      tool_use_id: "call-1",
-      name: "read_file",
-      content: { content: "{}" },
-      is_error: false,
-    });
-    expect(events).toContainEqual({ type: "text", text: "done", accumulated: "done" });
-  });
-
-  it("writes raw CCC fullStream parts when raw stream logs are enabled", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    config.rawStreamLogs.ccc = {
-      enabled: true,
-      maxBytesPerTurn: 4096,
-      retentionDays: 3,
-      keepCompleted: true,
-    };
-    createRawStreamLogMock.mockResolvedValueOnce({
-      filePath: "raw.jsonl.gz",
-      writeLine: rawLogWriteLineMock,
-      close: rawLogCloseMock,
-    });
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        sessionId: "raw-log-session",
-      },
-    );
-    const textPart = { type: "text-delta", text: "hello" };
-    const toolPart = {
-      type: "tool-call",
-      toolCallId: "call-1",
-      toolName: "read_file",
-      input: { path: "package.json" },
-    };
-
-    streamTextMock.mockReturnValueOnce({
-      fullStream: fullStream(textPart, toolPart),
-    });
-
-    await collect(session.chat("hi"));
-
-    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
-      enabled: true,
-      tool: "ccc",
-      sessionId: "raw-log-session",
-      label: "prompt",
-      maxBytesPerTurn: 4096,
-      retentionDays: 3,
-    }));
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(textPart));
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(toolPart));
-    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: true });
-  });
-});
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { config } from "../config.ts";
+
+const streamTextMock = vi.fn();
+const generateTextMock = vi.fn();
+const createRawStreamLogMock = vi.fn();
+const rawLogWriteLineMock = vi.fn();
+const rawLogCloseMock = vi.fn();
+const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
+vi.mock("ai", () => ({
+  streamText: streamTextMock,
+  generateText: generateTextMock,
+  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
+  stepCountIs: vi.fn((count: number) => ({ count })),
+  jsonSchema: vi.fn((schema: unknown) => schema),
+  tool: vi.fn((definition: unknown) => definition),
+}));
+
+vi.mock("../adapters/raw-stream-log.ts", () => ({
+  createRawStreamLog: createRawStreamLogMock,
+}));
+
+async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
+  const events: unknown[] = [];
+  for await (const event of iterable) events.push(event);
+  return events;
+}
+
+async function* textStream(...chunks: string[]): AsyncIterable<string> {
+  for (const chunk of chunks) yield chunk;
+}
+
+async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
+  for (const part of parts) yield part;
+}
+
+afterEach(() => {
+  streamTextMock.mockReset();
+  generateTextMock.mockReset();
+  createRawStreamLogMock.mockReset();
+  rawLogWriteLineMock.mockReset();
+  rawLogCloseMock.mockReset();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+});
+
+describe("ChatSession context management", () => {
+  it("injects cwd project instruction files before runtime workspace details", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-instructions-"));
+    await writeFile(join(dir, "AGENTS.md"), "agents root guidance", "utf-8");
+    await writeFile(join(dir, "AGENTS.local.md"), "agents local guidance", "utf-8");
+    await writeFile(join(dir, "CLAUDE.md"), "claude root guidance", "utf-8");
+    await writeFile(join(dir, "CLAUDE.local.md"), "claude local guidance", "utf-8");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: dir,
+        sessionId: "project-instructions",
+      },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).toContain("## Project Instructions");
+    expect(system).toContain("### AGENTS.md");
+    expect(system).toContain("agents root guidance");
+    expect(system).toContain("### AGENTS.local.md");
+    expect(system).toContain("agents local guidance");
+    expect(system).toContain("### CLAUDE.md");
+    expect(system).toContain("claude root guidance");
+    expect(system).toContain("### CLAUDE.local.md");
+    expect(system).toContain("claude local guidance");
+
+    expect(system.indexOf("agents root guidance")).toBeLessThan(system.indexOf("agents local guidance"));
+    expect(system.indexOf("agents local guidance")).toBeLessThan(system.indexOf("claude root guidance"));
+    expect(system.indexOf("claude root guidance")).toBeLessThan(system.indexOf("claude local guidance"));
+    expect(system.indexOf("claude local guidance")).toBeLessThan(system.indexOf(dir));
+  });
+
+  it("does not read project instruction files from parent directories", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const parent = await mkdtemp(join(tmpdir(), "chatccc-session-parent-instructions-"));
+    const child = join(parent, "child");
+    await mkdir(child);
+    await writeFile(join(parent, "AGENTS.md"), "parent-only guidance", "utf-8");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: child,
+        sessionId: "no-parent-instructions",
+      },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).not.toContain("parent-only guidance");
+  });
+
+  it("uses loop-finished stopping by default", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-unlimited-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: dir,
+        sessionId: "unlimited-steps",
+      },
+    );
+    await collect(session.chat("run a multi-stage workflow"));
+
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      stopWhen: { loopFinished: true },
+    }));
+  });
+
+  it("uses a configured tool step limit when provided", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-step-budget-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: dir,
+        sessionId: "step-budget",
+        maxSteps: 7,
+      },
+    );
+    await collect(session.chat("run a bounded workflow"));
+
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      stopWhen: { count: 7 },
+    }));
+  });
+
+  it("loads persisted context, compacts older messages, and persists the new assistant reply", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-context-"));
+
+    const seed = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "integration",
+        compactAtTokens: 10_000,
+      },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
+    await collect(seed.chat("old question"));
+
+    generateTextMock.mockResolvedValueOnce({ text: "## 当前任务状态\n- 旧问题已总结" });
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("new answer") });
+
+    const restored = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "integration",
+        compactAtTokens: 1,
+        keepRecentMessages: 1,
+      },
+    );
+    const events = await collect(restored.chat("new question"));
+
+    expect(generateTextMock).toHaveBeenCalledOnce();
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      messages: expect.arrayContaining([
+        expect.objectContaining({ content: expect.stringContaining("旧问题已总结") }),
+        expect.objectContaining({ role: "user", content: "new question" }),
+      ]),
+    }));
+    expect(events).toContainEqual({ type: "compact", compactedMessages: 2 });
+    expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
+  });
+
+  it("streams tool calls and tool results from fullStream", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-tools-"));
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "tools",
+      },
+    );
+
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(
+        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "package.json" } },
+        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "{}" } },
+        { type: "text-delta", text: "done" },
+      ),
+    });
+
+    const events = await collect(session.chat("read package"));
+
+    expect(events).toContainEqual({
+      type: "tool_use",
+      id: "call-1",
+      name: "read_file",
+      input: { path: "package.json" },
+    });
+    expect(events).toContainEqual({
+      type: "tool_result",
+      tool_use_id: "call-1",
+      name: "read_file",
+      content: { content: "{}" },
+      is_error: false,
+    });
+    expect(events).toContainEqual({ type: "text", text: "done", accumulated: "done" });
+  });
+
+  it("writes raw CCC fullStream parts when raw stream logs are enabled", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    config.rawStreamLogs.ccc = {
+      enabled: true,
+      maxBytesPerTurn: 4096,
+      retentionDays: 3,
+      keepCompleted: true,
+    };
+    createRawStreamLogMock.mockResolvedValueOnce({
+      filePath: "raw.jsonl.gz",
+      writeLine: rawLogWriteLineMock,
+      close: rawLogCloseMock,
+    });
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        sessionId: "raw-log-session",
+      },
+    );
+    const textPart = { type: "text-delta", text: "hello" };
+    const toolPart = {
+      type: "tool-call",
+      toolCallId: "call-1",
+      toolName: "read_file",
+      input: { path: "package.json" },
+    };
+
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(textPart, toolPart),
+    });
+
+    await collect(session.chat("hi"));
+
+    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
+      enabled: true,
+      tool: "ccc",
+      sessionId: "raw-log-session",
+      label: "prompt",
+      maxBytesPerTurn: 4096,
+      retentionDays: 3,
+    }));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(textPart));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(toolPart));
+    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: true });
+  });
+});

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,33 +1,33 @@
-import { afterEach, describe, expect, it } from "vitest";
-
-import { ChatSession } from "../builtin/index.ts";
-import { config } from "../config.ts";
-
-const originalDeepSeekApiKey = process.env.DEEPSEEK_API_KEY;
-const originalCccConfig = structuredClone(config.ccc);
-
-afterEach(() => {
-  if (originalDeepSeekApiKey === undefined) {
-    delete process.env.DEEPSEEK_API_KEY;
-  } else {
-    process.env.DEEPSEEK_API_KEY = originalDeepSeekApiKey;
-  }
-  config.ccc = structuredClone(originalCccConfig);
-});
-
-describe("builtin ChatSession config", () => {
-  it("does not fall back to DEEPSEEK_API_KEY environment variable", () => {
-    config.ccc = {
-      DEEPSEEK_API_KEY: "",
-      DEEPSEEK_BASE_URL: "https://api.deepseek.com/v1",
-      model: "deepseek-v4-pro",
-    };
-    process.env.DEEPSEEK_API_KEY = "sk-env-should-not-be-used";
-
-    expect(() => new ChatSession()).toThrow("ccc.DEEPSEEK_API_KEY 未设置");
-  });
-
-  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 "../config.ts";
+
+const originalDeepSeekApiKey = process.env.DEEPSEEK_API_KEY;
+const originalCccConfig = structuredClone(config.ccc);
+
+afterEach(() => {
+  if (originalDeepSeekApiKey === undefined) {
+    delete process.env.DEEPSEEK_API_KEY;
+  } else {
+    process.env.DEEPSEEK_API_KEY = originalDeepSeekApiKey;
+  }
+  config.ccc = structuredClone(originalCccConfig);
+});
+
+describe("builtin ChatSession config", () => {
+  it("does not fall back to DEEPSEEK_API_KEY environment variable", () => {
+    config.ccc = {
+      DEEPSEEK_API_KEY: "",
+      DEEPSEEK_BASE_URL: "https://api.deepseek.com/v1",
+      model: "deepseek-v4-pro",
+    };
+    process.env.DEEPSEEK_API_KEY = "sk-env-should-not-be-used";
+
+    expect(() => new ChatSession()).toThrow("ccc.DEEPSEEK_API_KEY 未设置");
+  });
+
+  it("allows constructor parameters to override config defaults", () => {
+    expect(() => new ChatSession({ apiKey: "sk-test" })).not.toThrow();
+  });
+});