chatccc 0.2.4 → 0.2.5

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<{
@@ -148,4 +151,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>;
+}

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);
+}

package/src/config.ts

@@ -62,6 +62,9 @@ export const CLAUDE_MODEL = process.env.CHATCCC_ANTHROPIC_MODEL?.trim() || "defa
 
 export const CLAUDE_EFFORT = process.env.CHATCCC_ANTHROPIC_EFFORT?.trim() || "default";
 
+/** AI 工具选择：claude | cursor | codex（未设置时默认 claude） */
+export const AI_TOOL = process.env.CHATCCC_AI_TOOL?.trim().toLowerCase() || "claude";
+
 // 新建会话的默认工作路径（/cd 命令设置，持久化到本地文件）
 // 该路径仅影响通过 /new 新建的 Claude 会话，不影响已有会话的 resume。
 export const DEFAULT_CWD_FILE = join(PROJECT_ROOT, ".claude", "working_dir.txt");
@@ -224,4 +227,4 @@ export function explainMissingFeishuCredentialsAndExit(): never {
   process.exit(1);
 }
 
-export const SESSION_DESC_PREFIX = "Claude Session:";
+export let SESSION_DESC_PREFIX: string = "Claude Session:";

package/src/index.ts

@@ -22,7 +22,6 @@
  */
 
 import { spawn } from "node:child_process";
-import { getSessionInfo } from "@anthropic-ai/claude-agent-sdk";
 import { readdir, stat } from "node:fs/promises";
 import { resolve, dirname, basename } from "node:path";
 
@@ -79,6 +78,8 @@ import {
   resetState,
   resumeAndPrompt,
   sessionInfoMap,
+  initAdapter,
+  getAdapter,
 } from "./session.ts";
 
 // ---------------------------------------------------------------------------
@@ -190,7 +191,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
       const chatInfo = await getChatInfo(cdToken, chatId);
       const sid = extractSessionId(chatInfo.description);
       if (sid) {
-        const info = await getSessionInfo(sid);
+        const info = await getAdapter().getSessionInfo(sid);
         sessionCwd = info?.cwd;
       }
     } catch { /* 非会话群或获取失败，不显示 */ }
@@ -648,6 +649,7 @@ async function main(): Promise<void> {
   });
 
   if (USE_LOCAL) {
+    initAdapter();
     console.log(`\n[启动 6/7] 本地区 relay 模式：正在连接 ${LOCAL_RELAY_URL} …`);
     console.log("  若失败：请先在 SDK 模式下启动主进程，或确认本机中继已在该地址监听。");
     let localRelayOpened = false;
@@ -693,12 +695,13 @@ async function main(): Promise<void> {
     });
   } else {
     resetState();
+    initAdapter();
 
     const wsClient = new WSClient({
       appId: APP_ID,
       appSecret: APP_SECRET,
-      onReady: () => resetState(),
-      onReconnected: () => resetState(),
+      onReady: () => { resetState(); initAdapter(); },
+      onReconnected: () => { resetState(); initAdapter(); },
     });
 
     console.log(`\n[启动 6/7] 飞书长连接：正在通过 SDK 建立 WebSocket …`);