chatccc 0.2.4 → 0.2.6

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

@@ -0,0 +1,250 @@
+import { describe, it, expect } from "vitest";
+import { normalizeCursorMessage, createCursorAdapter } from "../adapters/cursor-adapter.ts";
+import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
+
+// ---------------------------------------------------------------------------
+// normalizeCursorMessage — 核心映射逻辑测试（纯函数）
+// ---------------------------------------------------------------------------
+
+describe("normalizeCursorMessage", () => {
+  // --- assistant messages ---
+
+  it("normalizes assistant message with text block", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [{ type: "text", text: "Hello world" }],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([{ type: "text", text: "Hello world" }]);
+  });
+
+  it("normalizes assistant message with thinking block", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [{ type: "thinking", thinking: "Let me think..." }],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([{ type: "thinking", thinking: "Let me think..." }]);
+  });
+
+  it("normalizes assistant message with tool_use block", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "tool_use", name: "read_file", input: { filePath: "/tmp/test" } },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", name: "read_file", input: { filePath: "/tmp/test" } },
+    ]);
+  });
+
+  it("uses 'unknown' for tool_use without name", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: { role: "assistant", content: [{ type: "tool_use", input: {} }] },
+    });
+    expect(result!.blocks[0]).toMatchObject({ type: "tool_use", name: "unknown" });
+  });
+
+  it("normalizes assistant message with search_result block", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [{ type: "search_result", query: "cursor docs" }],
+      },
+    });
+    expect(result!.blocks).toEqual([{ type: "search_result", query: "cursor docs" }]);
+  });
+
+  it("normalizes assistant message with redacted_thinking block", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: { role: "assistant", content: [{ type: "redacted_thinking" }] },
+    });
+    expect(result!.blocks).toEqual([{ type: "redacted_thinking" }]);
+  });
+
+  // --- user messages (tool_result) ---
+
+  it("normalizes user message with tool_result block (success)", () => {
+    const result = normalizeCursorMessage({
+      type: "user",
+      message: {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "call_abc", content: "done", is_error: false },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("user");
+    expect(result!.blocks).toEqual([
+      { type: "tool_result", tool_use_id: "call_abc", content: "done", is_error: false },
+    ]);
+  });
+
+  it("normalizes user message with tool_result block (error)", () => {
+    const result = normalizeCursorMessage({
+      type: "user",
+      message: {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "call_err", content: "fail", is_error: true },
+        ],
+      },
+    });
+    expect(result!.blocks).toEqual([
+      { type: "tool_result", tool_use_id: "call_err", content: "fail", is_error: true },
+    ]);
+  });
+
+  // --- mixed blocks ---
+
+  it("normalizes message with multiple block types", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "Hmm..." },
+          { type: "tool_use", name: "search", input: { query: "x" } },
+          { type: "text", text: "Result found." },
+        ],
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toHaveLength(3);
+  });
+
+  // --- edge cases ---
+
+  it("returns null for result messages (completion signal)", () => {
+    expect(
+      normalizeCursorMessage({
+        type: "result",
+        subtype: "success",
+        result: "done",
+      }),
+    ).toBeNull();
+  });
+
+  it("returns null for system init messages", () => {
+    expect(
+      normalizeCursorMessage({
+        type: "system",
+        subtype: "init",
+        session_id: "abc",
+      }),
+    ).toBeNull();
+  });
+
+  it("returns null for unknown message types", () => {
+    expect(normalizeCursorMessage({ type: "unknown_type" })).toBeNull();
+    expect(normalizeCursorMessage({})).toBeNull();
+  });
+
+  it("skips unknown block types in content", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "custom_block", data: "ignored" },
+          { type: "text", text: "visible" },
+        ],
+      },
+    });
+    expect(result!.blocks).toEqual([{ type: "text", text: "visible" }]);
+  });
+
+  it("returns message with empty blocks for empty content array", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: { role: "assistant", content: [] },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([]);
+  });
+
+  it("returns null for message without content", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: { role: "assistant" },
+    });
+    expect(result).toBeNull();
+  });
+
+  it("skips thinking block with empty string", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: { role: "assistant", content: [{ type: "thinking", thinking: "" }] },
+    });
+    expect(result!.blocks).toEqual([]);
+  });
+
+  it("skips text block with empty string", () => {
+    const result = normalizeCursorMessage({
+      type: "assistant",
+      message: { role: "assistant", content: [{ type: "text", text: "" }] },
+    });
+    expect(result!.blocks).toEqual([]);
+  });
+
+  it("returns null for system message without compact_boundary subtype", () => {
+    expect(
+      normalizeCursorMessage({ type: "system", subtype: "notification" }),
+    ).toBeNull();
+  });
+
+  it("normalizes system compact_boundary message", () => {
+    const msg: Record<string, unknown> = {
+      type: "system",
+      subtype: "compact_boundary",
+      compact_metadata: { trigger: "auto", pre_tokens: 15000, post_tokens: 8000 },
+    };
+    const result = normalizeCursorMessage(
+      msg as Parameters<typeof normalizeCursorMessage>[0],
+    );
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("system");
+    expect(result!.blocks).toEqual([
+      { type: "compact_boundary", trigger: "auto", pre_tokens: 15000, post_tokens: 8000 },
+    ]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createCursorAdapter — 工厂函数测试
+// ---------------------------------------------------------------------------
+
+describe("createCursorAdapter", () => {
+  it("returns adapter with correct displayName and sessionDescPrefix", () => {
+    const adapter = createCursorAdapter();
+    expect(adapter.displayName).toBe("Cursor");
+    expect(adapter.sessionDescPrefix).toBe("Cursor Session:");
+  });
+
+  it("closeSession does not throw", async () => {
+    const adapter = createCursorAdapter();
+    await expect(adapter.closeSession("any-id")).resolves.toBeUndefined();
+  });
+
+  it("getSessionInfo returns basic info", async () => {
+    const adapter = createCursorAdapter();
+    const info = await adapter.getSessionInfo("test-sid");
+    expect(info).toEqual({ sessionId: "test-sid" });
+  });
+});

package/src/__tests__/session.test.ts

@@ -7,7 +7,10 @@ import {
   resetState,
   getSessionStatus,
   getAllSessionsStatus,
+  accumulateBlockContent,
 } from "../session.ts";
+import type { AccumulatorState } from "../session.ts";
+import type { UnifiedBlock } from "../adapters/adapter-interface.ts";
 
 // Helper to create a mock active session entry
 function mockActiveSession(chatId: string, overrides: Partial<{
@@ -42,6 +45,7 @@ function mockSessionInfo(chatId: string, overrides: Partial<{
     startTime: overrides.startTime ?? Date.now(),
     model: "Claude Opus 4.7",
     effort: "high",
+    tool: "claude",
   });
 }
 
@@ -54,7 +58,7 @@ describe("resetState", () => {
     });
     sessionInfoMap.set("chat1", {
       sessionId: "s1", turnCount: 1, lastContextTokens: 0,
-      startTime: 0, model: "", effort: "",
+      startTime: 0, model: "", effort: "", tool: "claude",
     });
     processedMessages.add("msg1");
 
@@ -148,4 +152,146 @@ describe("processedMessages dedup", () => {
   it("MAX_PROCESSED is defined", () => {
     expect(MAX_PROCESSED).toBe(5000);
   });
+});
+
+// ---------------------------------------------------------------------------
+// accumulateBlockContent — 统一消息块累积测试
+// ---------------------------------------------------------------------------
+
+function freshState(): AccumulatorState {
+  return { accumulatedContent: "", finalText: "", chunkCount: 0 };
+}
+
+describe("accumulateBlockContent", () => {
+  it("accumulates thinking block into accumulatedContent", () => {
+    const s = freshState();
+    accumulateBlockContent({ type: "thinking", thinking: "Let me think..." }, s);
+    expect(s.accumulatedContent).toBe("Let me think...");
+    expect(s.chunkCount).toBe(1);
+    expect(s.finalText).toBe("");
+  });
+
+  it("accumulates text block into finalText", () => {
+    const s = freshState();
+    accumulateBlockContent({ type: "text", text: "Hello world" }, s);
+    expect(s.finalText).toBe("Hello world");
+    expect(s.accumulatedContent).toBe("");
+  });
+
+  it("accumulates tool_use block with formatted name and input", () => {
+    const s = freshState();
+    accumulateBlockContent(
+      { type: "tool_use", name: "Read", input: { file_path: "/tmp/test.txt" } },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("📖"); // 📖
+    expect(s.accumulatedContent).toContain("**Read**");
+    expect(s.accumulatedContent).toContain("file_path");
+  });
+
+  it("accumulates tool_use block with long input truncated", () => {
+    const s = freshState();
+    const longInput = "x".repeat(500);
+    accumulateBlockContent(
+      { type: "tool_use", name: "Bash", input: longInput },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("...");
+    // Should be truncated to 300 + "..."
+    const inputPart = s.accumulatedContent.split("`")[1];
+    expect(inputPart.length).toBeLessThanOrEqual(304); // 300 + "..."
+  });
+
+  it("accumulates tool_result block with success icon (✅)", () => {
+    const s = freshState();
+    accumulateBlockContent(
+      { type: "tool_result", tool_use_id: "tool_abc123", content: "done", is_error: false },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("✅"); // ✅
+    expect(s.accumulatedContent).toContain("abc123");
+    expect(s.accumulatedContent).toContain("done");
+  });
+
+  it("accumulates tool_result block with error icon (❌)", () => {
+    const s = freshState();
+    accumulateBlockContent(
+      { type: "tool_result", tool_use_id: "tool_err456", content: "failed", is_error: true },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("❌"); // ❌
+  });
+
+  it("accumulates tool_result with array content (text blocks)", () => {
+    const s = freshState();
+    const content = [{ type: "text", text: "line1" }, { type: "text", text: "line2" }];
+    accumulateBlockContent(
+      { type: "tool_result", tool_use_id: "tool_arr", content },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("line1line2");
+  });
+
+  it("accumulates tool_result with object content (JSON stringified)", () => {
+    const s = freshState();
+    accumulateBlockContent(
+      { type: "tool_result", tool_use_id: "tool_obj", content: { key: "val" } },
+      s,
+    );
+    expect(s.accumulatedContent).toContain('{"key":"val"}');
+  });
+
+  it("accumulates redacted_thinking block with safety notice", () => {
+    const s = freshState();
+    accumulateBlockContent({ type: "redacted_thinking" }, s);
+    expect(s.accumulatedContent).toContain("内容被安全过滤"); // 内容被安全过滤
+  });
+
+  it("accumulates search_result block with query", () => {
+    const s = freshState();
+    accumulateBlockContent(
+      { type: "search_result", query: "TypeScript docs" },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("🔍"); // 🔍
+    expect(s.accumulatedContent).toContain("TypeScript docs");
+  });
+
+  it("accumulates compact_boundary block with trigger label", () => {
+    const s = freshState();
+    accumulateBlockContent(
+      { type: "compact_boundary", trigger: "auto", pre_tokens: 15000, post_tokens: 8000 },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("🔄"); // 🔄
+    expect(s.accumulatedContent).toContain("自动");
+    expect(s.accumulatedContent).toContain("15000");
+    expect(s.accumulatedContent).toContain("8000");
+  });
+
+  it("accumulates compact_boundary with manual trigger label", () => {
+    const s = freshState();
+    accumulateBlockContent(
+      { type: "compact_boundary", trigger: "manual", pre_tokens: 20000 },
+      s,
+    );
+    expect(s.accumulatedContent).toContain("手动");
+  });
+
+  it("accumulates multiple blocks in sequence correctly", () => {
+    const s = freshState();
+    accumulateBlockContent({ type: "thinking", thinking: "Hmm..." }, s);
+    accumulateBlockContent({ type: "tool_use", name: "Grep", input: { pattern: "foo" } }, s);
+    accumulateBlockContent(
+      { type: "tool_result", tool_use_id: "abc123", content: "found 3 matches", is_error: false },
+      s,
+    );
+    accumulateBlockContent({ type: "text", text: "I found the results." }, s);
+
+    expect(s.accumulatedContent).toContain("Hmm...");
+    expect(s.accumulatedContent).toContain("Grep");
+    expect(s.accumulatedContent).toContain("found 3 matches");
+    expect(s.finalText).toBe("I found the results.");
+    expect(s.chunkCount).toBe(1); // Only thinking increments chunkCount
+  });
 });

package/src/adapters/adapter-interface.ts

@@ -0,0 +1,127 @@
+// =============================================================================
+// adapter-interface.ts — 统一的 AI 工具适配器接口和归一化消息类型
+// =============================================================================
+// 所有 AI 工具适配器（Claude SDK、Cursor CLI、Codex CLI 等）都必须实现
+// ToolAdapter 接口。归一化消息类型 UnifiedBlock 屏蔽了各工具的差异，
+// 使 session.ts 不需要关心底层是哪个 AI 工具。
+// =============================================================================
+
+// ---------------------------------------------------------------------------
+// UnifiedBlock — 归一化后的消息块
+// ---------------------------------------------------------------------------
+
+export interface UnifiedThinkingBlock {
+  type: "thinking";
+  thinking: string;
+}
+
+export interface UnifiedTextBlock {
+  type: "text";
+  text: string;
+}
+
+export interface UnifiedToolUseBlock {
+  type: "tool_use";
+  name: string;
+  input: unknown;
+}
+
+export interface UnifiedToolResultBlock {
+  type: "tool_result";
+  tool_use_id: string;
+  content: unknown;
+  is_error?: boolean;
+}
+
+export interface UnifiedRedactedThinkingBlock {
+  type: "redacted_thinking";
+}
+
+export interface UnifiedSearchResultBlock {
+  type: "search_result";
+  query: string;
+}
+
+export interface UnifiedCompactBoundaryBlock {
+  type: "compact_boundary";
+  trigger: "manual" | "auto";
+  pre_tokens: number;
+  post_tokens?: number;
+}
+
+export type UnifiedBlock =
+  | UnifiedThinkingBlock
+  | UnifiedTextBlock
+  | UnifiedToolUseBlock
+  | UnifiedToolResultBlock
+  | UnifiedRedactedThinkingBlock
+  | UnifiedSearchResultBlock
+  | UnifiedCompactBoundaryBlock;
+
+// ---------------------------------------------------------------------------
+// UnifiedStreamMessage — 一次 SDK/CLI 事件对应的归一化消息
+// ---------------------------------------------------------------------------
+
+export interface UnifiedStreamMessage {
+  type: "assistant" | "user" | "system";
+  blocks: UnifiedBlock[];
+}
+
+// ---------------------------------------------------------------------------
+// CreateSessionResult
+// ---------------------------------------------------------------------------
+
+export interface CreateSessionResult {
+  sessionId: string;
+}
+
+// ---------------------------------------------------------------------------
+// SessionInfo — 会话元数据（/status、/cd 等命令使用）
+// ---------------------------------------------------------------------------
+
+export interface SessionInfo {
+  sessionId: string;
+  cwd?: string;
+  summary?: string;
+  lastModified?: number;
+}
+
+// ---------------------------------------------------------------------------
+// ToolAdapter — 统一的 AI 工具适配器接口
+// ---------------------------------------------------------------------------
+
+export interface ToolAdapter {
+  /** 日志/展示用名称，如 "Claude" */
+  readonly displayName: string;
+
+  /** 群描述中会话 ID 的前缀，如 "Claude Session:" */
+  readonly sessionDescPrefix: string;
+
+  /**
+   * 创建新会话，返回会话 ID。
+   * 适配器内部需处理后台流消费（静默消费 stream 中除 init 外的所有事件）。
+   */
+  createSession(cwd: string): Promise<CreateSessionResult>;
+
+  /**
+   * 向已有会话发送提示文本，返回归一化消息的异步迭代器。
+   * 消费者遍历结束后（或提前中止时）适配器自动关闭底层会话。
+   */
+  prompt(
+    sessionId: string,
+    userText: string,
+    cwd: string,
+    signal?: AbortSignal,
+  ): AsyncIterable<UnifiedStreamMessage>;
+
+  /**
+   * 查询会话元数据。会话不存在时返回 undefined。
+   */
+  getSessionInfo(sessionId: string): Promise<SessionInfo | undefined>;
+
+  /**
+   * 关闭/清理会话（/stop 或中断时调用）。
+   * 对于流式结束后自动关闭的适配器（如 Claude SDK），此为 no-op。
+   */
+  closeSession(sessionId: string): Promise<void>;
+}