test: Phase 1 — 添加 8 个纯函数测试文件 (+134 tests)

- errors.test.ts: 28 tests (isAbortError, toError, errorMessage, getErrnoCode, isFsInaccessible, classifyAxiosError 等)
- shellRuleMatching.test.ts: 22 tests (permissionRuleExtractPrefix, hasWildcards, matchWildcardPattern, parsePermissionRule 等)
- argumentSubstitution.test.ts: 18 tests (parseArguments, parseArgumentNames, generateProgressiveArgumentHint, substituteArguments)
- CircularBuffer.test.ts: 12 tests (add, addAll, getRecent, toArray, clear, length)
- sanitization.test.ts: 14 tests (partiallySanitizeUnicode, recursivelySanitizeUnicode)
- slashCommandParsing.test.ts: 8 tests (parseSlashCommand)
- contentArray.test.ts: 6 tests (insertBlockAfterToolResults)
- objectGroupBy.test.ts: 5 tests (objectGroupBy)

总计：781 tests / 40 files

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: claude-code-best

src/utils/__tests__/CircularBuffer.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test";
+import { CircularBuffer } from "../CircularBuffer";
+
+describe("CircularBuffer", () => {
+  test("starts empty", () => {
+    const buf = new CircularBuffer<number>(5);
+    expect(buf.length()).toBe(0);
+    expect(buf.toArray()).toEqual([]);
+  });
+
+  test("adds items up to capacity", () => {
+    const buf = new CircularBuffer<number>(3);
+    buf.add(1);
+    buf.add(2);
+    buf.add(3);
+    expect(buf.length()).toBe(3);
+    expect(buf.toArray()).toEqual([1, 2, 3]);
+  });
+
+  test("evicts oldest when full", () => {
+    const buf = new CircularBuffer<number>(3);
+    buf.add(1);
+    buf.add(2);
+    buf.add(3);
+    buf.add(4);
+    expect(buf.length()).toBe(3);
+    expect(buf.toArray()).toEqual([2, 3, 4]);
+  });
+
+  test("evicts multiple oldest items", () => {
+    const buf = new CircularBuffer<number>(2);
+    buf.add(1);
+    buf.add(2);
+    buf.add(3);
+    buf.add(4);
+    buf.add(5);
+    expect(buf.toArray()).toEqual([4, 5]);
+  });
+
+  test("addAll adds multiple items", () => {
+    const buf = new CircularBuffer<number>(5);
+    buf.addAll([1, 2, 3]);
+    expect(buf.toArray()).toEqual([1, 2, 3]);
+  });
+
+  test("addAll with overflow", () => {
+    const buf = new CircularBuffer<number>(3);
+    buf.addAll([1, 2, 3, 4, 5]);
+    expect(buf.toArray()).toEqual([3, 4, 5]);
+  });
+
+  test("getRecent returns last N items", () => {
+    const buf = new CircularBuffer<number>(5);
+    buf.addAll([1, 2, 3, 4, 5]);
+    expect(buf.getRecent(3)).toEqual([3, 4, 5]);
+  });
+
+  test("getRecent returns fewer when not enough items", () => {
+    const buf = new CircularBuffer<number>(5);
+    buf.add(1);
+    buf.add(2);
+    expect(buf.getRecent(5)).toEqual([1, 2]);
+  });
+
+  test("getRecent works after wraparound", () => {
+    const buf = new CircularBuffer<number>(3);
+    buf.addAll([1, 2, 3, 4, 5]);
+    expect(buf.getRecent(2)).toEqual([4, 5]);
+  });
+
+  test("clear resets buffer", () => {
+    const buf = new CircularBuffer<number>(5);
+    buf.addAll([1, 2, 3]);
+    buf.clear();
+    expect(buf.length()).toBe(0);
+    expect(buf.toArray()).toEqual([]);
+  });
+
+  test("works with string type", () => {
+    const buf = new CircularBuffer<string>(2);
+    buf.add("a");
+    buf.add("b");
+    buf.add("c");
+    expect(buf.toArray()).toEqual(["b", "c"]);
+  });
+});

src/utils/__tests__/argumentSubstitution.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "bun:test";
+import {
+  parseArguments,
+  parseArgumentNames,
+  generateProgressiveArgumentHint,
+  substituteArguments,
+} from "../argumentSubstitution";
+
+// ─── parseArguments ─────────────────────────────────────────────────────
+
+describe("parseArguments", () => {
+  test("splits simple arguments", () => {
+    expect(parseArguments("foo bar baz")).toEqual(["foo", "bar", "baz"]);
+  });
+
+  test("handles quoted strings", () => {
+    expect(parseArguments('foo "hello world" baz')).toEqual([
+      "foo",
+      "hello world",
+      "baz",
+    ]);
+  });
+
+  test("handles single-quoted strings", () => {
+    expect(parseArguments("foo 'hello world' baz")).toEqual([
+      "foo",
+      "hello world",
+      "baz",
+    ]);
+  });
+
+  test("returns empty for empty string", () => {
+    expect(parseArguments("")).toEqual([]);
+  });
+
+  test("returns empty for whitespace only", () => {
+    expect(parseArguments("   ")).toEqual([]);
+  });
+});
+
+// ─── parseArgumentNames ─────────────────────────────────────────────────
+
+describe("parseArgumentNames", () => {
+  test("parses space-separated string", () => {
+    expect(parseArgumentNames("foo bar baz")).toEqual(["foo", "bar", "baz"]);
+  });
+
+  test("accepts array input", () => {
+    expect(parseArgumentNames(["foo", "bar"])).toEqual(["foo", "bar"]);
+  });
+
+  test("filters out numeric-only names", () => {
+    expect(parseArgumentNames("foo 123 bar")).toEqual(["foo", "bar"]);
+  });
+
+  test("filters out empty strings", () => {
+    expect(parseArgumentNames(["foo", "", "bar"])).toEqual(["foo", "bar"]);
+  });
+
+  test("returns empty for undefined", () => {
+    expect(parseArgumentNames(undefined)).toEqual([]);
+  });
+});
+
+// ─── generateProgressiveArgumentHint ────────────────────────────────────
+
+describe("generateProgressiveArgumentHint", () => {
+  test("shows remaining arguments", () => {
+    expect(generateProgressiveArgumentHint(["a", "b", "c"], ["x"])).toBe(
+      "[b] [c]"
+    );
+  });
+
+  test("returns undefined when all filled", () => {
+    expect(
+      generateProgressiveArgumentHint(["a"], ["x"])
+    ).toBeUndefined();
+  });
+
+  test("shows all when none typed", () => {
+    expect(generateProgressiveArgumentHint(["a", "b"], [])).toBe("[a] [b]");
+  });
+});
+
+// ─── substituteArguments ────────────────────────────────────────────────
+
+describe("substituteArguments", () => {
+  test("replaces $ARGUMENTS with full args", () => {
+    expect(substituteArguments("run $ARGUMENTS", "foo bar")).toBe(
+      "run foo bar"
+    );
+  });
+
+  test("replaces indexed $ARGUMENTS[0]", () => {
+    expect(substituteArguments("run $ARGUMENTS[0]", "foo bar")).toBe("run foo");
+  });
+
+  test("replaces shorthand $0, $1", () => {
+    expect(substituteArguments("$0 and $1", "hello world")).toBe(
+      "hello and world"
+    );
+  });
+
+  test("replaces named arguments", () => {
+    expect(
+      substituteArguments("file: $name", "test.txt", true, ["name"])
+    ).toBe("file: test.txt");
+  });
+
+  test("returns content unchanged for undefined args", () => {
+    expect(substituteArguments("hello", undefined)).toBe("hello");
+  });
+
+  test("appends ARGUMENTS when no placeholder found", () => {
+    expect(substituteArguments("run this", "extra")).toBe(
+      "run this\n\nARGUMENTS: extra"
+    );
+  });
+
+  test("does not append when appendIfNoPlaceholder is false", () => {
+    expect(substituteArguments("run this", "extra", false)).toBe("run this");
+  });
+
+  test("does not append for empty args string", () => {
+    expect(substituteArguments("run this", "")).toBe("run this");
+  });
+});

src/utils/__tests__/contentArray.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+import { insertBlockAfterToolResults } from "../contentArray";
+
+describe("insertBlockAfterToolResults", () => {
+  test("inserts after last tool_result", () => {
+    const content: any[] = [
+      { type: "tool_result", content: "r1" },
+      { type: "text", text: "hello" },
+    ];
+    insertBlockAfterToolResults(content, { type: "text", text: "inserted" });
+    expect(content[1]).toEqual({ type: "text", text: "inserted" });
+    expect(content).toHaveLength(3);
+  });
+
+  test("inserts after last of multiple tool_results", () => {
+    const content: any[] = [
+      { type: "tool_result", content: "r1" },
+      { type: "tool_result", content: "r2" },
+      { type: "text", text: "end" },
+    ];
+    insertBlockAfterToolResults(content, { type: "text", text: "new" });
+    expect(content[2]).toEqual({ type: "text", text: "new" });
+  });
+
+  test("appends continuation when inserted block would be last", () => {
+    const content: any[] = [{ type: "tool_result", content: "r1" }];
+    insertBlockAfterToolResults(content, { type: "text", text: "new" });
+    expect(content).toHaveLength(3); // original + inserted + continuation
+    expect(content[2]).toEqual({ type: "text", text: "." });
+  });
+
+  test("inserts before last block when no tool_results", () => {
+    const content: any[] = [
+      { type: "text", text: "a" },
+      { type: "text", text: "b" },
+    ];
+    insertBlockAfterToolResults(content, { type: "text", text: "new" });
+    expect(content[1]).toEqual({ type: "text", text: "new" });
+    expect(content).toHaveLength(3);
+  });
+
+  test("handles empty array", () => {
+    const content: any[] = [];
+    insertBlockAfterToolResults(content, { type: "text", text: "new" });
+    expect(content).toHaveLength(1);
+    expect(content[0]).toEqual({ type: "text", text: "new" });
+  });
+
+  test("handles single element array with no tool_result", () => {
+    const content: any[] = [{ type: "text", text: "only" }];
+    insertBlockAfterToolResults(content, { type: "text", text: "new" });
+    expect(content[0]).toEqual({ type: "text", text: "new" });
+    expect(content[1]).toEqual({ type: "text", text: "only" });
+  });
+});