chatccc 0.2.230 → 0.2.232

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

@@ -1,10 +1,12 @@
-import { mkdtemp, readFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { describe, expect, it } from "vitest";
 
 import {
+  buildPersistedAssistantMessage,
+  buildSummaryPrompt,
   BuiltinContextManager,
   estimateBuiltinContextTokens,
   listBuiltinContextSessions,
@@ -13,6 +15,43 @@ import {
 } from "../builtin/context.ts";
 
 describe("BuiltinContextManager", () => {
+  it("keeps recent messages within the token budget instead of a fixed count", () => {
+    const context = new BuiltinContextManager({
+      compactAtTokens: 300,
+      keepRecentMessages: 16,
+      persist: false,
+    });
+    for (let index = 0; index < 8; index += 1) {
+      context.appendMessage({
+        role: index % 2 === 0 ? "user" : "assistant",
+        content: `${index}:` + "x".repeat(400),
+      });
+    }
+
+    const plan = context.planCompaction();
+
+    expect(plan).not.toBeNull();
+    expect(plan!.recentMessages.length).toBeLessThan(8);
+    expect(plan!.recentMessages.at(-1)?.content).toContain("7:");
+    expect(estimateBuiltinContextTokens("", plan!.recentMessages)).toBeLessThanOrEqual(300);
+  });
+
+  it("bounds oversized source material sent to the compaction model", () => {
+    const context = new BuiltinContextManager({
+      compactAtTokens: 100,
+      keepRecentMessages: 1,
+      persist: false,
+    });
+    context.setSummary("previous ".repeat(30_000));
+    context.appendMessage({ role: "assistant", content: "a".repeat(200_000) });
+    context.appendMessage({ role: "user", content: "latest request" });
+
+    const prompt = buildSummaryPrompt(context.planCompaction()!);
+
+    expect(prompt.length).toBeLessThan(90_000);
+    expect(prompt).toContain("truncated for compaction");
+  });
+
   it("persists and restores summary, messages, and total message count", async () => {
     const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-context-"));
 
@@ -42,10 +81,11 @@ describe("BuiltinContextManager", () => {
 
   it("selects only older messages for compaction and keeps recent messages raw", () => {
     const context = new BuiltinContextManager({
-      compactAtTokens: 1,
+      compactAtTokens: 100,
       keepRecentMessages: 2,
       persist: false,
     });
+    context.setSummary("x".repeat(500));
     context.appendMessage({ role: "user", content: "旧用户消息" });
     context.appendMessage({ role: "assistant", content: "旧助手回复" });
     context.appendMessage({ role: "user", content: "近期用户消息" });
@@ -88,6 +128,122 @@ describe("BuiltinContextManager", () => {
     ]);
   });
 
+  it("persists structured tool calls and restores them", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-context-tools-"));
+
+    const first = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "tool-persisted",
+    });
+    first.appendMessage({
+      role: "assistant",
+      content: "回复\n\n[Tool transcript]\ntool_call run_command: {}\ntool_result run_command: {}",
+      toolCalls: [
+        { name: "run_command", input: "{\"command\":\"npm test\"}", output: "{\"exitCode\":0}" },
+        { name: "read_file", input: "{\"path\":\"a.ts\"}", output: "...", is_error: true },
+      ],
+    });
+    first.save();
+
+    const restored = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "tool-persisted",
+    });
+
+    expect(restored.messages[0].toolCalls).toEqual([
+      { name: "run_command", input: "{\"command\":\"npm test\"}", output: "{\"exitCode\":0}" },
+      { name: "read_file", input: "{\"path\":\"a.ts\"}", output: "...", is_error: true },
+    ]);
+  });
+
+  it("loads legacy context files without toolCalls and filters malformed entries", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-context-legacy-"));
+    const state = {
+      version: 1,
+      createdAt: 1,
+      updatedAt: 2,
+      sessionId: "legacy",
+      summary: "",
+      totalMessages: 2,
+      compactedMessages: 0,
+      messages: [
+        { role: "assistant", content: "老消息" },
+        {
+          role: "assistant",
+          content: "带 toolCalls",
+          toolCalls: [
+            { name: "ok", input: "{\"a\":1}" },
+            { name: "" }, // 非法：空 name 应被过滤
+            { input: "no-name" }, // 非法：缺 name 应被过滤
+            { name: "bad-type", input: 42 }, // 非法：input 非 string 应被忽略字段
+          ],
+        },
+      ],
+    };
+    await mkdir(join(dir, "legacy"));
+    await writeFile(join(dir, "legacy", "context.json"), JSON.stringify(state), "utf8");
+
+    const restored = new BuiltinContextManager({
+      persist: true,
+      contextDir: dir,
+      sessionId: "legacy",
+    });
+
+    expect(restored.messages[0].toolCalls).toBeUndefined();
+    expect(restored.messages[1].toolCalls).toEqual([
+      { name: "ok", input: "{\"a\":1}" },
+      { name: "bad-type" },
+    ]);
+    expect(restored.totalMessages).toBe(2);
+  });
+
+  it("builds a persisted assistant message with transcript text plus structured tool calls", () => {
+    const message = buildPersistedAssistantMessage({
+      fullText: "回复正文",
+      transcriptLines: [
+        "tool_call run_command: {\"command\":\"npm test\"}",
+        "tool_result run_command: {\"exitCode\":0}",
+      ],
+      toolCalls: [
+        { name: "run_command", input: "{\"command\":\"npm test\"}", output: "{\"exitCode\":0}" },
+      ],
+    });
+
+    expect(message.role).toBe("assistant");
+    expect(message.content).toContain("回复正文");
+    expect(message.content).toContain("[Tool transcript]");
+    expect(message.content).toContain("tool_call run_command");
+    expect(message.toolCalls).toEqual([
+      { name: "run_command", input: "{\"command\":\"npm test\"}", output: "{\"exitCode\":0}" },
+    ]);
+  });
+
+  it("builds a plain assistant message without tool transcript when no tools ran", () => {
+    const message = buildPersistedAssistantMessage({
+      fullText: "纯文本回复",
+      transcriptLines: [],
+    });
+
+    expect(message.content).toBe("纯文本回复");
+    expect(message.content).not.toContain("[Tool transcript]");
+    expect(message.toolCalls).toBeUndefined();
+  });
+
+  it("caps both assistant text and tool transcript in persisted messages", () => {
+    const message = buildPersistedAssistantMessage({
+      fullText: "a".repeat(10_000),
+      transcriptLines: Array.from({ length: 12 }, () => "x".repeat(8_000)),
+      maxAssistantChars: 2_000,
+      maxTranscriptChars: 4_000,
+    });
+
+    expect(message.content.length).toBeLessThan(7_000);
+    expect(message.content).toContain("assistant response truncated");
+    expect(message.content).toContain("tool transcript truncated");
+  });
+
   it("reset clears memory and the persisted context file", async () => {
     const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-context-reset-"));
     const context = new BuiltinContextManager({

package/src/__tests__/builtin-file-tools.test.ts

@@ -1,240 +1,240 @@
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
-import { promisify } from "node:util";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import {
-  applyPatchForTool,
-  createFileForTool,
-  deleteFileForTool,
-  editFileForTool,
-  expandHomePath,
-  listDirForTool,
-  moveFileForTool,
-  readFileForTool,
-  runCommandForTool,
-  searchCodeForTool,
-} from "../builtin/file-tools.ts";
-
-const execFileAsync = promisify(execFile);
-const tempDirs: string[] = [];
-
-async function makeTempDir(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "deepccc-tools-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("expandHomePath", () => {
-  it("expands ~ and ~/ (both separators) to the user home directory", () => {
-    const home = homedir();
-    expect(expandHomePath("~")).toBe(home);
-    expect(expandHomePath("~/x/y.txt")).toBe(join(home, "x", "y.txt"));
-    expect(expandHomePath("~\\x\\y.txt")).toBe(join(home, "x", "y.txt"));
-  });
-
-  it("leaves absolute paths and other inputs unchanged", () => {
-    expect(expandHomePath("C:/a/b")).toBe("C:/a/b");
-    expect(expandHomePath("~other/x")).toBe("~other/x");
-    expect(expandHomePath("")).toBe("");
-  });
-});
-
-async function hasRg(): Promise<boolean> {
-  try {
-    await execFileAsync("rg", ["--version"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function sha256(text: string): string {
-  return createHash("sha256").update(text).digest("hex");
-}
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-
-describe("DeepCCC file tools", () => {
-  it("reads a text file with line ranges", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, ".secret.txt"), "one\ntwo\nthree\n", "utf8");
-
-    const result = await readFileForTool(dir, { path: ".secret.txt", startLine: 2, endLine: 3 });
-
-    expect(result).toEqual(expect.objectContaining({
-      sha256: sha256("one\ntwo\nthree\n"),
-      isBinary: false,
-      content: "two\nthree",
-      startLine: 2,
-      endLine: 3,
-      totalLines: 4,
-    }));
-    expect(result.path).toContain(".secret.txt");
-  });
-
-  it("lists directory entries including hidden files", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, ".env"), "TOKEN=x", "utf8");
-
-    const result = await listDirForTool(dir);
-
-    expect(result.entries).toContainEqual(expect.objectContaining({
-      name: ".env",
-      type: "file",
-    }));
-  });
-
-  it("searches code with rg without using a shell", async () => {
-    if (!await hasRg()) return;
-
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "a.ts"), "const marker = 1;\n", "utf8");
-
-    const result = await searchCodeForTool(dir, { query: "marker", glob: "*.ts" });
-
-    expect(result.matches).toEqual([
-      expect.objectContaining({
-        line: 1,
-        text: "const marker = 1;",
-      }),
-    ]);
-  });
-
-  it("runs non-interactive shell commands in the requested cwd", async () => {
-    const dir = await makeTempDir();
-
-    const result = await runCommandForTool(dir, {
-      command: "node -e \"process.stdout.write(process.cwd())\"",
-      timeoutMs: 5_000,
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(result.timedOut).toBe(false);
-    expect(result.stdout.toLowerCase()).toBe(dir.toLowerCase());
-    expect(result.stderr).toBe("");
-  });
-
-  it("returns non-zero command exits without throwing", async () => {
-    const dir = await makeTempDir();
-
-    const result = await runCommandForTool(dir, {
-      command: "node -e \"process.stderr.write('failed'); process.exit(7)\"",
-      timeoutMs: 5_000,
-    });
-
-    expect(result.exitCode).toBe(7);
-    expect(result.stderr).toBe("failed");
-    expect(result.timedOut).toBe(false);
-  });
-
-  it("edits a file with exact replacements and a SHA-256 precondition", async () => {
-    const dir = await makeTempDir();
-    const file = join(dir, "edit.txt");
-    await writeFile(file, "alpha\nbeta\ngamma\n", "utf8");
-
-    const result = await editFileForTool(dir, {
-      path: "edit.txt",
-      expectedSha256: sha256("alpha\nbeta\ngamma\n"),
-      edits: [{ oldText: "beta", newText: "BETA" }],
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      changed: true,
-      editsApplied: 1,
-      beforeSha256: sha256("alpha\nbeta\ngamma\n"),
-      afterSha256: sha256("alpha\nBETA\ngamma\n"),
-    }));
-    await expect(readFile(file, "utf8")).resolves.toBe("alpha\nBETA\ngamma\n");
-  });
-
-  it("rejects edits when the SHA-256 precondition does not match", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "edit.txt"), "current\n", "utf8");
-
-    await expect(editFileForTool(dir, {
-      path: "edit.txt",
-      expectedSha256: sha256("stale\n"),
-      edits: [{ oldText: "current", newText: "next" }],
-    })).rejects.toThrow("SHA-256 mismatch");
-  });
-
-  it("creates and deletes files", async () => {
-    const dir = await makeTempDir();
-
-    const created = await createFileForTool(dir, {
-      path: "created.txt",
-      content: "created\n",
-    });
-    expect(created).toEqual(expect.objectContaining({
-      changed: true,
-      afterSha256: sha256("created\n"),
-    }));
-    await expect(readFile(join(dir, "created.txt"), "utf8")).resolves.toBe("created\n");
-
-    const deleted = await deleteFileForTool(dir, {
-      path: "created.txt",
-      expectedSha256: sha256("created\n"),
-    });
-    expect(deleted).toEqual(expect.objectContaining({
-      deleted: true,
-      beforeSha256: sha256("created\n"),
-    }));
-    await expect(stat(join(dir, "created.txt"))).rejects.toThrow();
-  });
-
-  it("moves files and creates the destination directory", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "old.txt"), "move me\n", "utf8");
-
-    const result = await moveFileForTool(dir, {
-      sourcePath: "old.txt",
-      destinationPath: "nested/new.txt",
-      expectedSourceSha256: sha256("move me\n"),
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      moved: true,
-      sourceSha256: sha256("move me\n"),
-    }));
-    await expect(stat(join(dir, "old.txt"))).rejects.toThrow();
-    await expect(readFile(join(dir, "nested", "new.txt"), "utf8")).resolves.toBe("move me\n");
-  });
-
-  it("applies a unified diff patch", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "patch.txt"), "one\ntwo\nthree\n", "utf8");
-
-    const result = await applyPatchForTool(dir, {
-      patch: [
-        "--- a/patch.txt",
-        "+++ b/patch.txt",
-        "@@ -1,4 +1,4 @@",
-        " one",
-        "-two",
-        "+TWO",
-        " three",
-        " ",
-        "",
-      ].join("\n"),
-      expectedSha256ByPath: {
-        "patch.txt": sha256("one\ntwo\nthree\n"),
-      },
-    });
-
-    expect(result.changedFiles).toEqual([
-      expect.objectContaining({
-        action: "edit",
-        beforeSha256: sha256("one\ntwo\nthree\n"),
-        afterSha256: sha256("one\nTWO\nthree\n"),
-      }),
-    ]);
-    await expect(readFile(join(dir, "patch.txt"), "utf8")).resolves.toBe("one\nTWO\nthree\n");
-  });
-});
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  applyPatchForTool,
+  createFileForTool,
+  deleteFileForTool,
+  editFileForTool,
+  expandHomePath,
+  listDirForTool,
+  moveFileForTool,
+  readFileForTool,
+  runCommandForTool,
+  searchCodeForTool,
+} from "../builtin/file-tools.ts";
+
+const execFileAsync = promisify(execFile);
+const tempDirs: string[] = [];
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "deepccc-tools-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("expandHomePath", () => {
+  it("expands ~ and ~/ (both separators) to the user home directory", () => {
+    const home = homedir();
+    expect(expandHomePath("~")).toBe(home);
+    expect(expandHomePath("~/x/y.txt")).toBe(join(home, "x", "y.txt"));
+    expect(expandHomePath("~\\x\\y.txt")).toBe(join(home, "x", "y.txt"));
+  });
+
+  it("leaves absolute paths and other inputs unchanged", () => {
+    expect(expandHomePath("C:/a/b")).toBe("C:/a/b");
+    expect(expandHomePath("~other/x")).toBe("~other/x");
+    expect(expandHomePath("")).toBe("");
+  });
+});
+
+async function hasRg(): Promise<boolean> {
+  try {
+    await execFileAsync("rg", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sha256(text: string): string {
+  return createHash("sha256").update(text).digest("hex");
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("DeepCCC file tools", () => {
+  it("reads a text file with line ranges", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, ".secret.txt"), "one\ntwo\nthree\n", "utf8");
+
+    const result = await readFileForTool(dir, { path: ".secret.txt", startLine: 2, endLine: 3 });
+
+    expect(result).toEqual(expect.objectContaining({
+      sha256: sha256("one\ntwo\nthree\n"),
+      isBinary: false,
+      content: "two\nthree",
+      startLine: 2,
+      endLine: 3,
+      totalLines: 4,
+    }));
+    expect(result.path).toContain(".secret.txt");
+  });
+
+  it("lists directory entries including hidden files", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, ".env"), "TOKEN=x", "utf8");
+
+    const result = await listDirForTool(dir);
+
+    expect(result.entries).toContainEqual(expect.objectContaining({
+      name: ".env",
+      type: "file",
+    }));
+  });
+
+  it("searches code with rg without using a shell", async () => {
+    if (!await hasRg()) return;
+
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "a.ts"), "const marker = 1;\n", "utf8");
+
+    const result = await searchCodeForTool(dir, { query: "marker", glob: "*.ts" });
+
+    expect(result.matches).toEqual([
+      expect.objectContaining({
+        line: 1,
+        text: "const marker = 1;",
+      }),
+    ]);
+  });
+
+  it("runs non-interactive shell commands in the requested cwd", async () => {
+    const dir = await makeTempDir();
+
+    const result = await runCommandForTool(dir, {
+      command: "node -e \"process.stdout.write(process.cwd())\"",
+      timeoutMs: 5_000,
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.timedOut).toBe(false);
+    expect(result.stdout.toLowerCase()).toBe(dir.toLowerCase());
+    expect(result.stderr).toBe("");
+  });
+
+  it("returns non-zero command exits without throwing", async () => {
+    const dir = await makeTempDir();
+
+    const result = await runCommandForTool(dir, {
+      command: "node -e \"process.stderr.write('failed'); process.exit(7)\"",
+      timeoutMs: 5_000,
+    });
+
+    expect(result.exitCode).toBe(7);
+    expect(result.stderr).toBe("failed");
+    expect(result.timedOut).toBe(false);
+  });
+
+  it("edits a file with exact replacements and a SHA-256 precondition", async () => {
+    const dir = await makeTempDir();
+    const file = join(dir, "edit.txt");
+    await writeFile(file, "alpha\nbeta\ngamma\n", "utf8");
+
+    const result = await editFileForTool(dir, {
+      path: "edit.txt",
+      expectedSha256: sha256("alpha\nbeta\ngamma\n"),
+      edits: [{ oldText: "beta", newText: "BETA" }],
+    });
+
+    expect(result).toEqual(expect.objectContaining({
+      changed: true,
+      editsApplied: 1,
+      beforeSha256: sha256("alpha\nbeta\ngamma\n"),
+      afterSha256: sha256("alpha\nBETA\ngamma\n"),
+    }));
+    await expect(readFile(file, "utf8")).resolves.toBe("alpha\nBETA\ngamma\n");
+  });
+
+  it("rejects edits when the SHA-256 precondition does not match", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "edit.txt"), "current\n", "utf8");
+
+    await expect(editFileForTool(dir, {
+      path: "edit.txt",
+      expectedSha256: sha256("stale\n"),
+      edits: [{ oldText: "current", newText: "next" }],
+    })).rejects.toThrow("SHA-256 mismatch");
+  });
+
+  it("creates and deletes files", async () => {
+    const dir = await makeTempDir();
+
+    const created = await createFileForTool(dir, {
+      path: "created.txt",
+      content: "created\n",
+    });
+    expect(created).toEqual(expect.objectContaining({
+      changed: true,
+      afterSha256: sha256("created\n"),
+    }));
+    await expect(readFile(join(dir, "created.txt"), "utf8")).resolves.toBe("created\n");
+
+    const deleted = await deleteFileForTool(dir, {
+      path: "created.txt",
+      expectedSha256: sha256("created\n"),
+    });
+    expect(deleted).toEqual(expect.objectContaining({
+      deleted: true,
+      beforeSha256: sha256("created\n"),
+    }));
+    await expect(stat(join(dir, "created.txt"))).rejects.toThrow();
+  });
+
+  it("moves files and creates the destination directory", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "old.txt"), "move me\n", "utf8");
+
+    const result = await moveFileForTool(dir, {
+      sourcePath: "old.txt",
+      destinationPath: "nested/new.txt",
+      expectedSourceSha256: sha256("move me\n"),
+    });
+
+    expect(result).toEqual(expect.objectContaining({
+      moved: true,
+      sourceSha256: sha256("move me\n"),
+    }));
+    await expect(stat(join(dir, "old.txt"))).rejects.toThrow();
+    await expect(readFile(join(dir, "nested", "new.txt"), "utf8")).resolves.toBe("move me\n");
+  });
+
+  it("applies a unified diff patch", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "patch.txt"), "one\ntwo\nthree\n", "utf8");
+
+    const result = await applyPatchForTool(dir, {
+      patch: [
+        "--- a/patch.txt",
+        "+++ b/patch.txt",
+        "@@ -1,4 +1,4 @@",
+        " one",
+        "-two",
+        "+TWO",
+        " three",
+        " ",
+        "",
+      ].join("\n"),
+      expectedSha256ByPath: {
+        "patch.txt": sha256("one\ntwo\nthree\n"),
+      },
+    });
+
+    expect(result.changedFiles).toEqual([
+      expect.objectContaining({
+        action: "edit",
+        beforeSha256: sha256("one\ntwo\nthree\n"),
+        afterSha256: sha256("one\nTWO\nthree\n"),
+      }),
+    ]);
+    await expect(readFile(join(dir, "patch.txt"), "utf8")).resolves.toBe("one\nTWO\nthree\n");
+  });
+});