chatccc 0.2.3 → 0.2.5

package/src/__tests__/session.test.ts

@@ -0,0 +1,296 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  chatSessionMap,
+  sessionInfoMap,
+  processedMessages,
+  MAX_PROCESSED,
+  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<{
+  accumulatedContent: string;
+  finalText: string;
+  stopped: boolean;
+}> = {}) {
+  chatSessionMap.set(chatId, {
+    gen: 1,
+    close: () => {},
+    cardId: null,
+    stopped: overrides.stopped ?? false,
+    accumulatedContent: overrides.accumulatedContent ?? "thinking...",
+    finalText: overrides.finalText ?? "",
+    spinnerTimer: null,
+    msgTimestamp: Date.now(),
+    sequence: 0,
+    cardBusy: false,
+  });
+}
+
+function mockSessionInfo(chatId: string, overrides: Partial<{
+  sessionId: string;
+  turnCount: number;
+  lastContextTokens: number;
+  startTime: number;
+}> = {}) {
+  sessionInfoMap.set(chatId, {
+    sessionId: overrides.sessionId ?? "test-session-id",
+    turnCount: overrides.turnCount ?? 3,
+    lastContextTokens: overrides.lastContextTokens ?? 50000,
+    startTime: overrides.startTime ?? Date.now(),
+    model: "Claude Opus 4.7",
+    effort: "high",
+  });
+}
+
+describe("resetState", () => {
+  it("clears all maps and sets", () => {
+    chatSessionMap.set("chat1", {
+      gen: 1, close: () => {}, cardId: null, stopped: false,
+      accumulatedContent: "", finalText: "", spinnerTimer: null,
+      msgTimestamp: 0, sequence: 0, cardBusy: false,
+    });
+    sessionInfoMap.set("chat1", {
+      sessionId: "s1", turnCount: 1, lastContextTokens: 0,
+      startTime: 0, model: "", effort: "",
+    });
+    processedMessages.add("msg1");
+
+    resetState();
+
+    expect(chatSessionMap.size).toBe(0);
+    expect(sessionInfoMap.size).toBe(0);
+    expect(processedMessages.size).toBe(0);
+  });
+});
+
+describe("getSessionStatus", () => {
+  beforeEach(() => {
+    chatSessionMap.clear();
+    sessionInfoMap.clear();
+  });
+
+  it("returns null for unknown chatId", () => {
+    expect(getSessionStatus("nonexistent")).toBeNull();
+  });
+
+  it("returns status for idle session (info exists, no active session)", () => {
+    mockSessionInfo("chat1");
+    const status = getSessionStatus("chat1");
+    expect(status).not.toBeNull();
+    expect(status!.sessionId).toBe("test-session-id");
+    expect(status!.running).toBe(false);
+    expect(status!.turnCount).toBe(3);
+    expect(status!.accumulatedLength).toBe(0);
+  });
+
+  it("returns running=true for active session", () => {
+    mockSessionInfo("chat1");
+    mockActiveSession("chat1", { accumulatedContent: "thinking...", finalText: "reply" });
+    const status = getSessionStatus("chat1");
+    expect(status!.running).toBe(true);
+    expect(status!.accumulatedLength).toBe(16); // "thinking..."(11) + "reply"(5)
+  });
+
+  it("returns running=false for stopped session", () => {
+    mockSessionInfo("chat1");
+    mockActiveSession("chat1", { stopped: true });
+    const status = getSessionStatus("chat1");
+    expect(status!.running).toBe(false);
+  });
+
+  it("returns correct turnCount and other info fields", () => {
+    mockSessionInfo("chat1", { turnCount: 7, lastContextTokens: 100000 });
+    const status = getSessionStatus("chat1");
+    expect(status!.turnCount).toBe(7);
+    expect(status!.lastContextTokens).toBe(100000);
+  });
+});
+
+describe("getAllSessionsStatus", () => {
+  beforeEach(() => {
+    chatSessionMap.clear();
+    sessionInfoMap.clear();
+  });
+
+  it("returns empty array when no sessions", () => {
+    expect(getAllSessionsStatus()).toEqual([]);
+  });
+
+  it("returns statuses for all recorded sessions", () => {
+    mockSessionInfo("chat1", { sessionId: "s1" });
+    mockSessionInfo("chat2", { sessionId: "s2" });
+    mockActiveSession("chat1");
+    const result = getAllSessionsStatus();
+    expect(result).toHaveLength(2);
+    expect(result.find(r => r.chatId === "chat1")!.active).toBe(true);
+    expect(result.find(r => r.chatId === "chat2")!.active).toBe(false);
+  });
+
+  it("marks stopped sessions as not active", () => {
+    mockSessionInfo("chat1");
+    mockActiveSession("chat1", { stopped: true });
+    const result = getAllSessionsStatus();
+    expect(result[0].active).toBe(false);
+  });
+});
+
+describe("processedMessages dedup", () => {
+  it("supports add/has semantics", () => {
+    processedMessages.clear();
+    processedMessages.add("msg_001");
+    expect(processedMessages.has("msg_001")).toBe(true);
+    expect(processedMessages.has("msg_002")).toBe(false);
+  });
+
+  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>;
+}

package/src/adapters/claude-adapter.ts

@@ -0,0 +1,257 @@
+// =============================================================================
+// claude-adapter.ts — Claude Agent SDK 适配器
+// =============================================================================
+// 实现 ToolAdapter 接口，将 @anthropic-ai/claude-agent-sdk 调用封装在内。
+// =============================================================================
+
+import {
+  unstable_v2_createSession,
+  unstable_v2_resumeSession,
+  getSessionInfo as sdkGetSessionInfo,
+} from "@anthropic-ai/claude-agent-sdk";
+
+import type {
+  ToolAdapter,
+  UnifiedBlock,
+  UnifiedStreamMessage,
+  CreateSessionResult,
+  SessionInfo,
+} from "./adapter-interface.ts";
+
+// ---------------------------------------------------------------------------
+// 类型别名：SDK 内部消息的形状（避免导入 sdk.d.ts 的大型联合类型）
+// ---------------------------------------------------------------------------
+
+interface SdkContentBlock {
+  type: string;
+  text?: string;
+  thinking?: string;
+  name?: string;
+  input?: unknown;
+  tool_use_id?: string;
+  content?: unknown;
+  is_error?: boolean;
+  query?: string;
+  [key: string]: unknown;
+}
+
+interface SdkMessageLike {
+  type?: string;
+  subtype?: string;
+  message?: { content?: SdkContentBlock[] };
+  compact_metadata?: {
+    trigger?: "manual" | "auto";
+    pre_tokens?: number;
+    post_tokens?: number;
+  };
+  session_id?: string;
+}
+
+// ---------------------------------------------------------------------------
+// ClaudeAdapterOptions
+// ---------------------------------------------------------------------------
+
+export interface ClaudeAdapterOptions {
+  model: string;
+  effort: string;
+  isDefault: (value: string) => boolean;
+}
+
+// ---------------------------------------------------------------------------
+// buildSessionOptions — 还原 claudeSdkSessionOptions 的精确行为
+// ---------------------------------------------------------------------------
+
+function buildSessionOptions(
+  cwd: string,
+  model: string,
+  effort: string,
+  isDefault: (value: string) => boolean,
+): Record<string, unknown> {
+  const o: Record<string, unknown> = {
+    cwd,
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    autoCompactEnabled: true,
+  };
+  if (!isDefault(model)) o.model = model;
+  if (!isDefault(effort)) o.effort = effort;
+  return o;
+}
+
+// ---------------------------------------------------------------------------
+// normalizeSdkMessage — 关键映射：SDK 消息 → UnifiedStreamMessage | null
+// ---------------------------------------------------------------------------
+
+export function normalizeSdkMessage(msg: SdkMessageLike): UnifiedStreamMessage | null {
+  // 1) assistant / user 消息：遍历 content 块
+  if (
+    (msg.type === "assistant" || msg.type === "user") &&
+    msg.message?.content
+  ) {
+    const blocks: UnifiedBlock[] = [];
+    for (const block of msg.message.content) {
+      if (block.type === "thinking" && block.thinking) {
+        blocks.push({ type: "thinking", thinking: block.thinking });
+      } else if (block.type === "tool_use") {
+        blocks.push({
+          type: "tool_use",
+          name: block.name ?? "unknown",
+          input: block.input,
+        });
+      } else if (block.type === "tool_result") {
+        blocks.push({
+          type: "tool_result",
+          tool_use_id: block.tool_use_id ?? "",
+          content: block.content,
+          is_error: block.is_error,
+        });
+      } else if (block.type === "redacted_thinking") {
+        blocks.push({ type: "redacted_thinking" });
+      } else if (block.type === "search_result") {
+        blocks.push({
+          type: "search_result",
+          query: block.query ?? "",
+        });
+      } else if (block.type === "text" && block.text) {
+        blocks.push({ type: "text", text: block.text });
+      }
+    }
+    return { type: msg.type, blocks };
+  }
+
+  // 2) system / compact_boundary 消息：上下文压缩事件
+  if (msg.type === "system" && msg.subtype === "compact_boundary") {
+    const meta = msg.compact_metadata;
+    if (!meta) return null;
+    return {
+      type: "system",
+      blocks: [
+        {
+          type: "compact_boundary",
+          trigger: meta.trigger ?? "auto",
+          pre_tokens: meta.pre_tokens ?? 0,
+          post_tokens: meta.post_tokens,
+        },
+      ],
+    };
+  }
+
+  // 3) 其他消息类型：跳过
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// 适配器实现（私有类，仅通过工厂函数暴露）
+// ---------------------------------------------------------------------------
+
+class ClaudeAdapter implements ToolAdapter {
+  readonly displayName = "Claude";
+  readonly sessionDescPrefix = "Claude Session:";
+  private model: string;
+  private effort: string;
+  private isDefault: (value: string) => boolean;
+
+  constructor(options: ClaudeAdapterOptions) {
+    this.model = options.model;
+    this.effort = options.effort;
+    this.isDefault = options.isDefault;
+  }
+
+  async createSession(cwd: string): Promise<CreateSessionResult> {
+    const sessionOpts = buildSessionOptions(
+      cwd,
+      this.model,
+      this.effort,
+      this.isDefault,
+    );
+    const session = unstable_v2_createSession(sessionOpts as any);
+
+    await session.send("ok");
+
+    const stream = session.stream();
+    const first = await stream.next();
+
+    if (first.done || !(first.value as SdkMessageLike)?.session_id) {
+      session.close();
+      throw new Error("No session ID in Claude init event");
+    }
+
+    const sessionId = (first.value as SdkMessageLike).session_id!;
+
+    // 后台消费剩余的 stream（必须：否则 SDK 内部缓冲可能阻塞）
+    (async () => {
+      try {
+        for await (const _msg of stream) {
+          // 静默消费
+        }
+      } catch {
+        // stream 异常不阻塞主流程
+      } finally {
+        session.close();
+      }
+    })();
+
+    return { sessionId };
+  }
+
+  async *prompt(
+    sessionId: string,
+    userText: string,
+    cwd: string,
+    signal?: AbortSignal,
+  ): AsyncIterable<UnifiedStreamMessage> {
+    const sessionOpts = buildSessionOptions(
+      cwd,
+      this.model,
+      this.effort,
+      this.isDefault,
+    );
+    const session = unstable_v2_resumeSession(
+      sessionId,
+      sessionOpts as any,
+    );
+
+    await session.send(userText);
+
+    const stream = session.stream();
+
+    try {
+      for await (const msg of stream) {
+        if (signal?.aborted) break;
+        const normalized = normalizeSdkMessage(
+          msg as unknown as SdkMessageLike,
+        );
+        if (normalized) yield normalized;
+      }
+    } finally {
+      session.close();
+    }
+  }
+
+  async getSessionInfo(
+    sessionId: string,
+  ): Promise<SessionInfo | undefined> {
+    const info = await sdkGetSessionInfo(sessionId);
+    if (!info) return undefined;
+    return {
+      sessionId: info.sessionId,
+      cwd: info.cwd,
+      summary: info.summary,
+      lastModified: info.lastModified,
+    };
+  }
+
+  async closeSession(_sessionId: string): Promise<void> {
+    // Claude SDK 在 stream 结束后自动关闭 session，此处为 no-op
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 工厂函数
+// ---------------------------------------------------------------------------
+
+export function createClaudeAdapter(
+  options: ClaudeAdapterOptions,
+): ToolAdapter {
+  return new ClaudeAdapter(options);
+}