chatccc 0.2.220 → 0.2.222

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.220",
+  "version": "0.2.222",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/builtin-chat-session.test.ts

@@ -53,6 +53,46 @@ afterEach(() => {
   config.rawStreamLogs = structuredClone(originalRawStreamLogs);
 });
 
+describe("ChatSession codex-style skills", () => {
+  it("injects skill index into system prompt from skillsDirs", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-skills-"));
+    const skillsDir = join(dir, ".codex", "skills");
+    await mkdir(join(skillsDir, "demo-skill"), { recursive: true });
+    await writeFile(
+      join(skillsDir, "demo-skill", "SKILL.md"),
+      "---\nname: demo-skill\ndescription: 演示技能\n---\n\n# 演示",
+      "utf-8",
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { cwd: dir, sessionId: "skill-index", skillsDirs: [skillsDir] },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).toContain("## Available Skills");
+    expect(system).toContain("demo-skill");
+    expect(system).toContain("演示技能");
+  });
+
+  it("skips skill injection when no skills are found", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-no-skills-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { cwd: dir, sessionId: "no-skills", skillsDirs: [join(dir, "missing")] },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).not.toContain("## Available Skills");
+  });
+});
 describe("ChatSession context management", () => {
   it("injects cwd project instruction files before runtime workspace details", async () => {
     const { ChatSession } = await import("../builtin/index.ts");

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

@@ -158,6 +158,37 @@ describe("builtin file tools", () => {
     await expect(readFile(file, "utf8")).resolves.toBe("alpha\nBETA\ngamma\n");
   });
 
+  it("edits a CRLF file with LF oldText by normalizing line endings", async () => {
+    const dir = await makeTempDir();
+    const file = join(dir, "crlf.txt");
+    const crlfContent = "alpha\r\nbeta\r\ngamma\r\n";
+    await writeFile(file, crlfContent, "utf8");
+
+    const result = await editFileForTool(dir, {
+      path: "crlf.txt",
+      expectedSha256: sha256(crlfContent),
+      edits: [{ oldText: "alpha\nbeta", newText: "ALPHA\nBETA" }],
+    });
+
+    expect(result).toEqual(expect.objectContaining({
+      changed: true,
+      editsApplied: 1,
+      beforeSha256: sha256(crlfContent),
+      afterSha256: sha256("ALPHA\r\nBETA\r\ngamma\r\n"),
+    }));
+    await expect(readFile(file, "utf8")).resolves.toBe("ALPHA\r\nBETA\r\ngamma\r\n");
+  });
+
+  it("rejects a multi-line oldText that still does not match after EOL normalization", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "crlf.txt"), "alpha\r\nbeta\r\n", "utf8");
+
+    await expect(editFileForTool(dir, {
+      path: "crlf.txt",
+      edits: [{ oldText: "alpha\ngamma", newText: "x" }],
+    })).rejects.toThrow("oldText was not found");
+  });
+
   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");

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

@@ -0,0 +1,141 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  buildSkillsIndexPrompt,
+  parseSkillFrontmatter,
+  scanSkillsDirs,
+} from "../builtin/skills.ts";
+
+const tempDirs: string[] = [];
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "chatccc-skills-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("parseSkillFrontmatter", () => {
+  it("parses name and description from frontmatter", () => {
+    const content = [
+      "---",
+      "name: feishu-doc-download-md",
+      "description: 下载飞书文档为 Markdown",
+      "---",
+      "",
+      "# 正文",
+    ].join("\n");
+    expect(parseSkillFrontmatter(content)).toEqual({
+      name: "feishu-doc-download-md",
+      description: "下载飞书文档为 Markdown",
+    });
+  });
+
+  it("returns null when there is no frontmatter", () => {
+    expect(parseSkillFrontmatter("# just a heading")).toBeNull();
+  });
+
+  it("tolerates missing description", () => {
+    expect(parseSkillFrontmatter("---\nname: minimal-skill\n---\n\nbody")).toEqual({
+      name: "minimal-skill",
+      description: "",
+    });
+  });
+
+  it("handles CRLF line endings", () => {
+    const content = "---\r\nname: crlf-skill\r\ndescription: CRLF 描述\r\n---\r\n\r\nbody";
+    expect(parseSkillFrontmatter(content)).toEqual({
+      name: "crlf-skill",
+      description: "CRLF 描述",
+    });
+  });
+});
+
+describe("scanSkillsDirs", () => {
+  it("scans multiple dirs, skips hidden/system dirs, dedupes by name (later dir wins)", async () => {
+    const dir = await makeTempDir();
+    const userA = join(dir, "codex-skills");
+    const userB = join(dir, "agents-skills");
+    const project = join(dir, "project-codex");
+    await mkdir(join(userA, "feishu-doc"), { recursive: true });
+    await mkdir(join(userA, ".system"), { recursive: true });
+    await mkdir(join(userA, "no-skill-dir"));
+    await mkdir(join(userB, "feishu-doc"), { recursive: true });
+    await mkdir(join(userB, "another"), { recursive: true });
+    await mkdir(join(project, "feishu-doc"), { recursive: true });
+
+    await writeFile(
+      join(userA, "feishu-doc", "SKILL.md"),
+      "---\nname: feishu-doc\ndescription: 用户级 A\n---\n",
+      "utf8",
+    );
+    await writeFile(
+      join(userA, ".system", "SKILL.md"),
+      "---\nname: system-skill\ndescription: 内置\n---\n",
+      "utf8",
+    );
+    await writeFile(
+      join(userB, "feishu-doc", "SKILL.md"),
+      "---\nname: feishu-doc\ndescription: 用户级 B\n---\n",
+      "utf8",
+    );
+    await writeFile(
+      join(userB, "another", "SKILL.md"),
+      "---\nname: another\ndescription: 另一个\n---\n",
+      "utf8",
+    );
+    await writeFile(
+      join(project, "feishu-doc", "SKILL.md"),
+      "---\nname: feishu-doc\ndescription: 项目级覆盖\n---\n",
+      "utf8",
+    );
+
+    const skills = scanSkillsDirs([userA, userB, project]);
+
+    // 去重：同名保留一个，后面的目录（项目级）覆盖前面的（用户级）
+    expect(skills).toHaveLength(2);
+    const byName = new Map(skills.map((s) => [s.name, s]));
+    expect(byName.get("feishu-doc")?.description).toBe("项目级覆盖");
+    expect(byName.get("feishu-doc")?.skillPath).toBe(join(project, "feishu-doc", "SKILL.md"));
+    expect(byName.get("another")?.description).toBe("另一个");
+    expect(byName.has("system-skill")).toBe(false); // 隐藏目录被排除
+  });
+
+  it("skips missing directories and dirs without SKILL.md", async () => {
+    const dir = await makeTempDir();
+    await mkdir(join(dir, "empty-dir"));
+
+    const skills = scanSkillsDirs([join(dir, "missing-dir"), join(dir, "empty-dir")]);
+
+    expect(skills).toEqual([]);
+  });
+});
+
+describe("buildSkillsIndexPrompt", () => {
+  it("renders a skill index with names, paths and descriptions", () => {
+    const prompt = buildSkillsIndexPrompt([
+      {
+        name: "feishu-doc",
+        description: "下载飞书文档",
+        skillPath: "C:\\users\\x\\skills\\feishu-doc\\SKILL.md",
+      },
+    ]);
+
+    expect(prompt).toContain("## Available Skills");
+    expect(prompt).toContain("**feishu-doc**");
+    expect(prompt).toContain("下载飞书文档");
+    expect(prompt).toContain("C:\\users\\x\\skills\\feishu-doc\\SKILL.md");
+    expect(prompt).toContain("read_file");
+  });
+
+  it("returns empty string for no skills", () => {
+    expect(buildSkillsIndexPrompt([])).toBe("");
+  });
+});

package/src/__tests__/cards.test.ts

@@ -13,6 +13,7 @@ import {
   buildButtons,
   truncateContent,
   getToolEmoji,
+  normalizeToolName,
 } from "../cards.ts";
 import { ABD_HELP_LINE } from "../shared-prefix.ts";
 
@@ -83,6 +84,25 @@ describe("getToolEmoji", () => {
     expect(getToolEmoji("AskUserQuestion")).toBe("\u{2753}");// ❓
   });
 
+  it("returns correct emoji for CCC builtin tool names (snake_case)", () => {
+    expect(getToolEmoji("read_file")).toBe("\u{1F4D6}");
+    expect(getToolEmoji("list_dir")).toBe("\u{1F4C2}");
+    expect(getToolEmoji("search_code")).toBe("\u{1F50E}");
+    expect(getToolEmoji("run_command")).toBe("\u{1F5A5}\u{FE0F}");
+    expect(getToolEmoji("edit_file")).toBe("\u{270F}\u{FE0F}");
+    expect(getToolEmoji("create_file")).toBe("\u{270D}\u{FE0F}");
+    expect(getToolEmoji("delete_file")).toBe("\u{1F5D1}\u{FE0F}");
+    expect(getToolEmoji("move_file")).toBe("\u{1F4E6}");
+    expect(getToolEmoji("apply_patch")).toBe("\u{1F4CB}");
+  });
+
+  it("normalizeToolName converts snake_case to PascalCase", () => {
+    expect(normalizeToolName("read_file")).toBe("ReadFile");
+    expect(normalizeToolName("run_command")).toBe("RunCommand");
+    expect(normalizeToolName("Read")).toBe("Read");
+    expect(normalizeToolName("")).toBe("");
+  });
+
   it("returns wrench for unknown tool names", () => {
     expect(getToolEmoji("UnknownTool")).toBe("\u{1F527}");
     expect(getToolEmoji("cat")).toBe("\u{1F527}");

package/src/builtin/file-tools.ts

@@ -979,13 +979,19 @@ export async function editFileForTool(cwd: string, input: EditFileInput): Promis
   const before = await readEditableTextFile(filePath);
   assertExpectedSha256(filePath, before.sha, input.expectedSha256);
 
-  let text = before.text;
+  // Normalize line endings before matching so that LF-based oldText/newText
+  // (which is what models typically emit) works against CRLF files checked
+  // out on Windows. The file's dominant EOL style is restored on write.
+  const eol = detectEol(before.text);
+  let text = eol === "\r\n" ? before.text.replace(/\r\n/g, "\n") : before.text;
   let editsApplied = 0;
   for (const [index, edit] of input.edits.entries()) {
     if (!edit.oldText) {
       throw new Error(`edit ${index + 1} oldText must not be empty`);
     }
-    const count = countOccurrences(text, edit.oldText);
+    const oldText = edit.oldText.replace(/\r\n/g, "\n");
+    const newText = edit.newText.replace(/\r\n/g, "\n");
+    const count = countOccurrences(text, oldText);
     if (count === 0) {
       throw new Error(`edit ${index + 1} oldText was not found in ${filePath}`);
     }
@@ -993,10 +999,14 @@ export async function editFileForTool(cwd: string, input: EditFileInput): Promis
       throw new Error(`edit ${index + 1} oldText matched ${count} times in ${filePath}; set replaceAll=true or provide more context`);
     }
     text = edit.replaceAll
-      ? replaceAllLiteral(text, edit.oldText, edit.newText)
-      : text.replace(edit.oldText, edit.newText);
+      ? replaceAllLiteral(text, oldText, newText)
+      : text.replace(oldText, newText);
     editsApplied += edit.replaceAll ? count : 1;
   }
+  if (eol === "\r\n") {
+    // After normalization above the buffer contains only \n, so this is safe.
+    text = text.replace(/\n/g, "\r\n");
+  }
 
   assertTextSize(filePath, text, MAX_EDIT_BYTES);
   const afterSha = sha256(text);

package/src/builtin/index.ts

@@ -20,6 +20,7 @@ import {
   defaultBuiltinSessionId,
 } from "./context.ts";
 import { createBuiltinFileTools } from "./file-tools.ts";
+import { buildDefaultSkillDirs, buildSkillsIndexPrompt, scanSkillsDirs } from "./skills.ts";
 
 // ---------------------------------------------------------------------------
 // 系统提示词 — 编译期冻结常量
@@ -118,6 +119,11 @@ export interface ChatSessionOptions {
   keepRecentMessages?: number;
   /** Optional tool-step limit. Leave unset for no step limit. */
   maxSteps?: number;
+  /**
+   * Codex-style skill 扫描目录（<dir>/<name>/SKILL.md）。
+   * 缺省扫描 ~/.codex/skills、~/.agents/skills、<cwd>/.codex/skills。
+   */
+  skillsDirs?: string[];
 }
 
 /**
@@ -180,6 +186,12 @@ export class ChatSession {
     if (projectInstructions) {
       systemContent.push("", projectInstructions);
     }
+    // Codex-style skills 索引注入（name + description + 路径，模型按需 read_file 全文）
+    const skills = scanSkillsDirs(options.skillsDirs ?? buildDefaultSkillDirs(this.cwd));
+    const skillsPrompt = buildSkillsIndexPrompt(skills);
+    if (skillsPrompt) {
+      systemContent.push("", skillsPrompt);
+    }
     if (options.systemPrompt) {
       systemContent.push("", options.systemPrompt);
     }

package/src/builtin/skills.ts

@@ -0,0 +1,108 @@
+/**
+ * builtin/skills.ts — Codex-style skills 支持
+ *
+ * 从用户级（~/.codex/skills、~/.agents/skills）和项目级（<cwd>/.codex/skills）
+ * 扫描 Codex 目录式 skill（<name>/SKILL.md），解析 frontmatter 中的
+ * name + description，生成索引注入 system prompt。模型按需用 read_file
+ * 读取 SKILL.md 全文并执行（索引注入省 token，触发靠 description + 指令）。
+ */
+
+import { readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface BuiltinSkill {
+  name: string;
+  description: string;
+  /** SKILL.md 的绝对路径 */
+  skillPath: string;
+}
+
+/** 解析 SKILL.md frontmatter（兼容 CRLF），返回 name + description；无 frontmatter 返回 null */
+export function parseSkillFrontmatter(
+  content: string,
+): { name: string; description: string } | null {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/.exec(content);
+  if (!match) return null;
+  const fm = match[1];
+  const nameMatch = /^name:\s*(.+?)\s*$/m.exec(fm);
+  if (!nameMatch) return null;
+  const descMatch = /^description:\s*(.+?)\s*$/m.exec(fm);
+  return {
+    name: nameMatch[1].trim(),
+    description: descMatch?.[1].trim() ?? "",
+  };
+}
+
+/**
+ * 扫描多个 skill 目录，返回去重后的 skill 列表。
+ * 同名 skill 后面的目录覆盖前面的（调用方应把项目级目录放最后）。
+ * 隐藏目录（.system 等）和无 SKILL.md 的目录会被跳过。
+ */
+export function scanSkillsDirs(dirs: string[]): BuiltinSkill[] {
+  const byName = new Map<string, BuiltinSkill>();
+
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue; // 目录不存在或不可读：跳过
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue; // 排除 .system 等隐藏/内置目录
+
+      const skillPath = join(dir, entry.name, "SKILL.md");
+      let content: string;
+      try {
+        content = readFileSync(skillPath, "utf-8");
+      } catch {
+        continue; // 没有 SKILL.md 的目录不是 skill
+      }
+
+      const parsed = parseSkillFrontmatter(content);
+      if (!parsed) continue;
+
+      byName.set(parsed.name, {
+        name: parsed.name,
+        description: parsed.description,
+        skillPath,
+      });
+    }
+  }
+
+  return [...byName.values()];
+}
+
+/**
+ * 默认 skill 扫描目录：
+ * 1. ~/.codex/skills（Codex CLI 旧路径，用户实际在用的地方）
+ * 2. ~/.agents/skills（Codex 标准全局目录）
+ * 3. <cwd>/.codex/skills（项目级，优先级最高，放最后）
+ */
+export function buildDefaultSkillDirs(cwd: string): string[] {
+  return [
+    join(homedir(), ".codex", "skills"),
+    join(homedir(), ".agents", "skills"),
+    join(cwd, ".codex", "skills"),
+  ];
+}
+
+/**
+ * 生成 skill 索引提示词（注入 system prompt）。
+ * 索引只含 name + description + 路径，并指示模型在任务匹配时
+ * 先用 read_file 读取 SKILL.md 全文再执行——这是触发率的关键。
+ */
+export function buildSkillsIndexPrompt(skills: BuiltinSkill[]): string {
+  if (skills.length === 0) return "";
+
+  const lines = [
+    "## Available Skills (Codex-style)",
+    "The following Codex-style skills are available on this machine. When a user request matches a skill's description, first read its full SKILL.md with read_file, then follow the instructions in it exactly.",
+    "",
+    ...skills.map((s) => `- **${s.name}** (\`${s.skillPath}\`): ${s.description || "(no description)"}`),
+  ];
+  return lines.join("\n");
+}

package/src/cards.ts

@@ -70,10 +70,29 @@ const TOOL_EMOJI_MAP: Record<string, string> = {
   Agent: "\u{1F916}",         // 🤖
   NotebookEdit: "\u{1F4D3}",  // 📓
   AskUserQuestion: "\u{2753}",// ❓
+  // CCC 内置 Agent 下划线命名（getToolEmoji 会先把下划线转驼峰再查表，这里保留蛇形条目以便直接命中）
+  read_file: "\u{1F4D6}",          // 📖
+  list_dir: "\u{1F4C2}",          // 📂
+  search_code: "\u{1F50E}",       // 🔎
+  run_command: "\u{1F5A5}\u{FE0F}", // 🖥️
+  edit_file: "\u{270F}\u{FE0F}",  // ✏️
+  create_file: "\u{270D}\u{FE0F}", // ✍️
+  delete_file: "\u{1F5D1}\u{FE0F}", // 🗑️
+  move_file: "\u{1F4E6}",         // 📦
+  apply_patch: "\u{1F4CB}",       // 📋
 };
 
 export function getToolEmoji(name: string): string {
-  return TOOL_EMOJI_MAP[name] ?? "\u{1F527}"; // 🔧
+  return TOOL_EMOJI_MAP[name] ?? TOOL_EMOJI_MAP[normalizeToolName(name)] ?? "\u{1F527}"; // 🔧
+}
+
+/** 把下划线命名转成驼峰（read_file → ReadFile），用于兼容两种命名风格 */
+export function normalizeToolName(name: string): string {
+  return name
+    .split("_")
+    .filter((part) => part.length > 0)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
 }
 
 // ---------------------------------------------------------------------------