chatccc 0.2.251 → 0.2.253

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

@@ -1,284 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync, utimesSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  normalizeSkillPathForPrompt,
-  parseSkillFrontmatter,
-  scanSkillsDirs,
-  buildDefaultSkillDirs,
-  buildSkillsIndexPrompt,
-  buildSkillTemplate,
-  type SkillDirSpec,
-  type SkillSource,
-  type SkillScope,
-} from "../../deepccc-agent/src/skills.ts";
-
-let tempRoot: string;
-
-beforeEach(() => {
-  tempRoot = mkdtempSync(join(tmpdir(), "deepccc-skills-"));
-});
-
-afterEach(() => {
-  try {
-    rmSync(tempRoot, { recursive: true, force: true });
-  } catch {}
-});
-
-function makeSkill(specDir: string, name: string, description: string): string {
-  const dir = join(specDir, name);
-  mkdirSync(dir, { recursive: true });
-  const skillPath = join(dir, "SKILL.md");
-  writeFileSync(skillPath, `---\nname: ${name}\ndescription: ${description}\n---\n\nbody\n`, "utf8");
-  return skillPath;
-}
-
-function spec(
-  dir: string,
-  source: SkillSource,
-  scope: SkillScope = "global",
-): SkillDirSpec {
-  return { dir, source, scope };
-}
-
-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 priority matrix", () => {
-  it("codex wins over cursor, cursor wins over claude for same-name skills", async () => {
-    const claudeDir = join(tempRoot, "claude");
-    const cursorDir = join(tempRoot, "cursor");
-    const codexDir = join(tempRoot, "codex");
-    makeSkill(claudeDir, "dupe", "claude version");
-    makeSkill(cursorDir, "dupe", "cursor version");
-    makeSkill(codexDir, "dupe", "codex version");
-    makeSkill(codexDir, "only-codex", "codex only");
-
-    const skills = await scanSkillsDirs([
-      spec(claudeDir, "claude"),
-      spec(cursorDir, "cursor"),
-      spec(codexDir, "codex"),
-    ]);
-
-    const byName = new Map(skills.map((s) => [s.name, s]));
-    expect(byName.get("dupe")?.description).toBe("codex version");
-    expect(byName.get("dupe")?.source).toBe("codex");
-    expect(byName.get("dupe")?.skillPath).toContain(join("codex", "dupe"));
-    expect(byName.get("only-codex")?.source).toBe("codex");
-  });
-
-  it("project scope wins over global scope within the same source", async () => {
-    const globalCodex = join(tempRoot, "codex-global");
-    const projectCodex = join(tempRoot, "codex-project");
-    makeSkill(globalCodex, "dup", "global version");
-    makeSkill(projectCodex, "dup", "project version");
-
-    const skills = await scanSkillsDirs([
-      spec(globalCodex, "codex", "global"),
-      spec(projectCodex, "codex", "project"),
-    ]);
-
-    const byName = new Map(skills.map((s) => [s.name, s]));
-    expect(byName.get("dup")?.description).toBe("project version");
-    expect(byName.get("dup")?.scope).toBe("project");
-  });
-
-  it("deepccc source has the highest priority over codex", async () => {
-    const codexDir = join(tempRoot, "codex");
-    const deepcccDir = join(tempRoot, "deepccc");
-    makeSkill(codexDir, "dup", "from codex");
-    makeSkill(deepcccDir, "dup", "from deepccc");
-
-    const skills = await scanSkillsDirs([
-      spec(codexDir, "codex"),
-      spec(deepcccDir, "deepccc"),
-    ]);
-
-    expect(skills.find((s) => s.name === "dup")?.description).toBe("from deepccc");
-    expect(skills.find((s) => s.name === "dup")?.source).toBe("deepccc");
-  });
-
-  it("skips hidden dirs, dirs without SKILL.md, and missing dirs", async () => {
-    const dir = join(tempRoot, "src");
-    mkdirSync(join(dir, ".system"), { recursive: true });
-    writeFileSync(join(dir, ".system", "SKILL.md"), "---\nname: system-skill\ndescription: x\n---\n", "utf8");
-    mkdirSync(join(dir, "no-skill-dir"));
-
-    makeSkill(dir, "ok", "fine");
-    const skills = await scanSkillsDirs([
-      spec(join(tempRoot, "missing-dir"), "codex"),
-      spec(dir, "codex"),
-    ]);
-
-    expect(skills).toHaveLength(1);
-    expect(skills[0].name).toBe("ok");
-  });
-});
-
-describe("scanSkillsDirs hot reload (mtime cache)", () => {
-  it("re-reads a skill after its SKILL.md content changes", async () => {
-    const dir = join(tempRoot, "src");
-    const skillPath = makeSkill(dir, "live", "v1");
-
-    const first = await scanSkillsDirs([spec(dir, "deepccc")]);
-    expect(first.find((s) => s.name === "live")?.description).toBe("v1");
-
-    writeFileSync(skillPath, "---\nname: live\ndescription: v2\n---\n\nbody\n", "utf8");
-    utimesSync(skillPath, new Date(Date.now() + 3000), new Date(Date.now() + 3000)); // 强制 mtime 前进
-
-    const second = await scanSkillsDirs([spec(dir, "deepccc")]);
-    expect(second.find((s) => s.name === "live")?.description).toBe("v2");
-  });
-
-  it("new skill dirs are picked up on the next scan", async () => {
-    const dir = join(tempRoot, "src");
-    makeSkill(dir, "a", "A");
-
-    const first = await scanSkillsDirs([spec(dir, "deepccc")]);
-    expect(first).toHaveLength(1);
-
-    makeSkill(dir, "b", "B"); // 新技能，无需改 mtime（目录枚举每次都做）
-    const second = await scanSkillsDirs([spec(dir, "deepccc")]);
-    expect(second.map((s) => s.name).sort()).toEqual(["a", "b"]);
-  });
-
-  it("unchanged skills return identical results across scans", async () => {
-    const dir = join(tempRoot, "src");
-    makeSkill(dir, "a", "A");
-
-    const first = await scanSkillsDirs([spec(dir, "deepccc")]);
-    const second = await scanSkillsDirs([spec(dir, "deepccc")]);
-    expect(second).toEqual(first);
-  });
-});
-
-describe("buildDefaultSkillDirs", () => {
-  it("orders dirs low->high priority: claude < cursor < codex < deepccc, project after global", () => {
-    const dirs = buildDefaultSkillDirs("C:/proj");
-    expect(dirs.map((d) => `${d.source}:${d.scope}`)).toEqual([
-      "claude:global",
-      "claude:project",
-      "cursor:global",
-      "cursor:project",
-      "codex:global",
-      "codex:global",
-      "codex:project",
-      "deepccc:global",
-      "deepccc:project",
-    ]);
-  });
-
-  it("points codex global dirs at ~/.codex/skills and ~/.agents/skills", () => {
-    const dirs = buildDefaultSkillDirs("C:/proj").filter((d) => d.source === "codex" && d.scope === "global");
-    expect(dirs.map((d) => d.dir)).toEqual([
-      join(require("node:os").homedir(), ".codex", "skills"),
-      join(require("node:os").homedir(), ".agents", "skills"),
-    ]);
-  });
-});
-
-describe("normalizeSkillPathForPrompt", () => {
-  it("abbreviates home-directory paths with ~ and normalizes separators", () => {
-    const home = homedir();
-    const abs = join(home, ".codex", "skills", "x", "SKILL.md");
-    expect(normalizeSkillPathForPrompt(abs)).toBe("~/.codex/skills/x/SKILL.md");
-    expect(normalizeSkillPathForPrompt(home)).toBe("~");
-  });
-
-  it("keeps paths outside the home directory unchanged (separators normalized)", () => {
-    expect(normalizeSkillPathForPrompt("C:\\proj\\.claude\\skills\\x\\SKILL.md")).toBe(
-      "C:/proj/.claude/skills/x/SKILL.md",
-    );
-  });
-});
-
-describe("buildSkillsIndexPrompt", () => {
-  it("renders index with source markers and the skill creation convention", () => {
-    const prompt = buildSkillsIndexPrompt([
-      {
-        name: "feishu-doc",
-        description: "下载飞书文档",
-        skillPath: "C:/x/feishu-doc/SKILL.md",
-        source: "codex",
-        scope: "global",
-      },
-    ]);
-
-    expect(prompt).toContain("## 可用技能");
-    expect(prompt).toContain("**feishu-doc**");
-    expect(prompt).toContain("[codex:global]");
-    expect(prompt).toContain("## 创建技能");
-    expect(prompt).toContain(".deepccc/skills");
-    expect(prompt).toContain("read_file");
-  });
-
-  it("renders home-abbreviated skill paths so the prompt stays stable across machines", () => {
-    const home = homedir();
-    const prompt = buildSkillsIndexPrompt([
-      {
-        name: "demo",
-        description: "d",
-        skillPath: join(home, ".codex", "skills", "demo", "SKILL.md"),
-        source: "codex",
-        scope: "global",
-      },
-    ]);
-
-    expect(prompt).toContain("~/.codex/skills/demo/SKILL.md");
-    expect(prompt).not.toContain(home);
-  });
-
-  it("returns empty string for no skills", () => {
-    expect(buildSkillsIndexPrompt([])).toBe("");
-  });
-});
-
-describe("buildSkillTemplate", () => {
-  it("renders a Codex-style SKILL.md with frontmatter", () => {
-    const tpl = buildSkillTemplate("my-skill", "does something");
-    expect(tpl.startsWith("---")).toBe(true);
-    expect(tpl).toContain("name: my-skill");
-    expect(tpl).toContain("description: does something");
-    expect(tpl).toContain("# my-skill");
-  });
-
-  it("defaults description to empty when omitted", () => {
-    const tpl = buildSkillTemplate("bare-skill", "");
-    expect(tpl).toContain("description: ");
-  });
-});

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

@@ -1,220 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  decodeDdgHref,
-  extractHtmlTitle,
-  htmlToPlainText,
-  parseDuckDuckGoHtml,
-  webFetchForTool,
-  webSearchForTool,
-  type FetchLike,
-} from "../../deepccc-agent/src/web-tools.ts";
-
-const DDG_HTML = `<!DOCTYPE html>
-<html>
-<head><title>Search results</title></head>
-<body>
-  <div class="result results_links results_links_deep web-result">
-    <h2 class="result__title">
-      <a rel="nofollow" class="result__a" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fnodejs.org%2Fen%2Fdocs&rut=abc">Node.js <b>Docs</b></a>
-    </h2>
-    <a rel="nofollow" class="result__snippet" href="//duckduckgo.com/l/?uddg=...">Official documentation for Node.js &amp; npm.</a>
-  </div>
-  <div class="result">
-    <a rel="nofollow" class="result__a" href="https://example.com/page">Example &quot;quoted&quot; page</a>
-    <a rel="nofollow" class="result__snippet" href="https://example.com/page">A plain snippet without highlight.</a>
-  </div>
-</body>
-</html>`;
-
-const WEB_FETCH_HTML = `<!DOCTYPE html>
-<html><head><title>Fetch &amp; Me</title></head>
-<body>
-  <style>.x { color: red }</style>
-  <script>alert("x")</script>
-  <h1>Hello World</h1>
-  <p>First paragraph with &amp; entity.</p>
-  <p>Second paragraph<br>with a break.</p>
-  <footer>bye</footer>
-</body></html>`;
-
-describe("parseDuckDuckGoHtml", () => {
-  it("extracts title, decoded url, and snippet per result", () => {
-    const results = parseDuckDuckGoHtml(DDG_HTML);
-    expect(results).toHaveLength(2);
-    expect(results[0]).toEqual({
-      title: "Node.js Docs",
-      url: "https://nodejs.org/en/docs",
-      snippet: "Official documentation for Node.js & npm.",
-    });
-    expect(results[1]).toEqual({
-      title: 'Example "quoted" page',
-      url: "https://example.com/page",
-      snippet: "A plain snippet without highlight.",
-    });
-  });
-
-  it("returns empty array for pages without results", () => {
-    expect(parseDuckDuckGoHtml("<html><body>no results here</body></html>")).toEqual([]);
-  });
-});
-
-describe("decodeDdgHref", () => {
-  it("decodes uddg redirect params and restores protocol", () => {
-    expect(
-      decodeDdgHref("//duckduckgo.com/l/?uddg=https%3A%2F%2Fnodejs.org%2Fen%2Fdocs&rut=abc"),
-    ).toBe("https://nodejs.org/en/docs");
-  });
-
-  it("passes through plain urls", () => {
-    expect(decodeDdgHref("https://example.com/a?b=1")).toBe("https://example.com/a?b=1");
-  });
-
-  it("returns input untouched when unparseable", () => {
-    expect(decodeDdgHref("not a url")).toBe("not a url");
-  });
-});
-
-describe("htmlToPlainText", () => {
-  it("strips scripts/styles, keeps block boundaries, decodes entities, compresses whitespace", () => {
-    const text = htmlToPlainText(WEB_FETCH_HTML);
-    expect(text).not.toContain("alert");
-    expect(text).not.toContain(".x {");
-    expect(text).toContain("Hello World");
-    expect(text).toContain("First paragraph with & entity.");
-    expect(text).toContain("Second paragraph\nwith a break.");
-    expect(text).toContain("bye");
-    // 段落间允许单个空行，但不得出现连续空行
-    expect(text).not.toContain("\n\n\n");
-  });
-});
-
-describe("extractHtmlTitle", () => {
-  it("extracts and decodes the title", () => {
-    expect(extractHtmlTitle(WEB_FETCH_HTML)).toBe("Fetch & Me");
-  });
-
-  it("returns empty string when no title", () => {
-    expect(extractHtmlTitle("<html><body>x</body></html>")).toBe("");
-  });
-});
-
-describe("webSearchForTool", () => {
-  function mockFetch(html: string, status = 200): FetchLike {
-    return async () =>
-      new Response(html, {
-        status,
-        headers: { "content-type": "text/html; charset=utf-8" },
-      });
-  }
-
-  it("returns parsed results from the search page", async () => {
-    const output = await webSearchForTool(
-      { query: "nodejs docs" },
-      { fetchImpl: mockFetch(DDG_HTML) },
-    );
-    expect(output.query).toBe("nodejs docs");
-    expect(output.results).toHaveLength(2);
-    expect(output.results[0].url).toBe("https://nodejs.org/en/docs");
-    expect(output.results[0].snippet).toContain("Node.js");
-    expect(typeof output.durationMs).toBe("number");
-  });
-
-  it("respects maxResults and caps at 10", async () => {
-    const html = Array.from({ length: 12 }, (_, i) => {
-      const title = `<a rel="nofollow" class="result__a" href="https://e.com/${i}">R${i}</a>`;
-      const snippet = `<a rel="nofollow" class="result__snippet" href="https://e.com/${i}">s${i}</a>`;
-      return `<div>${title}${snippet}</div>`;
-    }).join("");
-    const output = await webSearchForTool({ query: "many" }, { fetchImpl: mockFetch(html) });
-    expect(output.results).toHaveLength(5);
-    expect(output.truncated).toBe(true);
-
-    const output2 = await webSearchForTool({ query: "many", maxResults: 20 }, { fetchImpl: mockFetch(html) });
-    expect(output2.results).toHaveLength(10);
-  });
-
-  it("returns empty results (not an error) when the page has no matches", async () => {
-    const output = await webSearchForTool(
-      { query: "zzz-nothing" },
-      { fetchImpl: mockFetch("<html><body>no results</body></html>") },
-    );
-    expect(output.results).toEqual([]);
-    expect(output.truncated).toBe(false);
-  });
-
-  it("throws on empty query", async () => {
-    await expect(webSearchForTool({ query: "  " }, { fetchImpl: mockFetch("") })).rejects.toThrow(
-      "query is required",
-    );
-  });
-
-  it("throws on non-2xx response", async () => {
-    await expect(
-      webSearchForTool({ query: "x" }, { fetchImpl: mockFetch("blocked", 429) }),
-    ).rejects.toThrow("HTTP 429");
-  });
-});
-
-describe("webFetchForTool", () => {
-  function mockFetch(html: string, status = 200, contentType = "text/html; charset=utf-8"): FetchLike {
-    return async () =>
-      new Response(html, {
-        status,
-        headers: { "content-type": contentType },
-      });
-  }
-
-  it("fetches and converts html to plain text with title", async () => {
-    const output = await webFetchForTool(
-      { url: "https://example.com/page" },
-      { fetchImpl: mockFetch(WEB_FETCH_HTML) },
-    );
-    expect(output.title).toBe("Fetch & Me");
-    expect(output.text).toContain("Hello World");
-    expect(output.text).toContain("Second paragraph\nwith a break.");
-    expect(output.text).not.toContain("alert");
-    expect(output.contentType).toContain("text/html");
-    expect(output.chars).toBe(output.text.length);
-    expect(output.truncated).toBe(false);
-  });
-
-  it("truncates text beyond maxChars", async () => {
-    const output = await webFetchForTool(
-      { url: "https://example.com/long", maxChars: 10 },
-      { fetchImpl: mockFetch("<p>hello world and more</p>") },
-    );
-    expect(output.text).toBe("hello worl");
-    expect(output.truncated).toBe(true);
-    expect(output.chars).toBe(10);
-  });
-
-  it("truncates oversized response bodies", async () => {
-    const big = `<!DOCTYPE html><html><body><p>${"a".repeat(600 * 1024)}</p></body></html>`;
-    const output = await webFetchForTool(
-      { url: "https://example.com/big" },
-      { fetchImpl: mockFetch(big) },
-    );
-    expect(output.truncated).toBe(true);
-    expect(output.text.length).toBeLessThan(600 * 1024);
-  });
-
-  it("rejects non-http(s) protocols", async () => {
-    await expect(
-      webFetchForTool({ url: "file:///etc/passwd" }, { fetchImpl: mockFetch("") }),
-    ).rejects.toThrow("unsupported protocol");
-  });
-
-  it("rejects invalid urls", async () => {
-    await expect(
-      webFetchForTool({ url: "not a url" }, { fetchImpl: mockFetch("") }),
-    ).rejects.toThrow("invalid URL");
-  });
-
-  it("throws on missing url and non-2xx", async () => {
-    await expect(webFetchForTool({ url: "  " })).rejects.toThrow("url is required");
-    await expect(
-      webFetchForTool({ url: "https://example.com/404" }, { fetchImpl: mockFetch("nf", 404) }),
-    ).rejects.toThrow("HTTP 404");
-  });
-});

package/src/__tests__/card-action-routing.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { resolveFeishuCardActionChatType } from "../card-action-routing.ts";
-
-describe("resolveFeishuCardActionChatType", () => {
-  it("keeps card commands in a persisted private chat on the p2p route", () => {
-    expect(resolveFeishuCardActionChatType("private-chat", {
-      "private-chat": { chatType: "p2p" },
-    })).toBe("p2p");
-  });
-
-  it("defaults unknown and group chats to the group route", () => {
-    expect(resolveFeishuCardActionChatType("group-chat", {
-      "group-chat": { chatType: "group" },
-    })).toBe("group");
-    expect(resolveFeishuCardActionChatType("unknown-chat", {})).toBe("group");
-  });
-});

package/src/__tests__/card-plain-text.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { cardJsonToPlainText } from "../card-plain-text.ts";
-import { progressView } from "../progress/view.ts";
-import {
-  buildHelpCard,
-  buildProgressCard,
-  buildStatusCard,
-} from "../cards.ts";
-
-describe("cardJsonToPlainText", () => {
-  it("converts help cards to readable text with commands", () => {
-    const text = cardJsonToPlainText(buildHelpCard("hello"));
-
-    expect(text).toContain("# ChatCCC");
-    expect(text).toContain("hello");
-    expect(text).toContain("/new");
-    expect(text).toContain("/new cursor");
-    expect(text).toContain("/new codex");
-    expect(text).toContain("/restart");
-    expect(text).toContain("/update");
-    expect(text).toContain("/cd");
-    expect(text).toContain("/abd");
-  });
-
-  it("converts status cards from v1 card format", () => {
-    const text = cardJsonToPlainText(buildStatusCard("status body", "green"));
-
-    expect(text).toContain("# 会话状态");
-    expect(text).toContain("status body");
-  });
-
-  it("converts schema 2.0 progress cards", () => {
-    const text = cardJsonToPlainText(buildProgressCard(progressView({ text: "stream body" })));
-
-    expect(text).toContain("# 生成中...");
-    expect(text).toContain("stream body");
-    expect(text).toContain("/state");
-    expect(text).toContain("/stop");
-  });
-
-  it("returns null for invalid card json", () => {
-    expect(cardJsonToPlainText("{bad json")).toBeNull();
-  });
-});

package/src/__tests__/cardkit.test.ts

@@ -1,60 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { updateCardKitCard } from "../cardkit.ts";
-
-function abortError(): Error {
-  const err = new Error("aborted");
-  err.name = "AbortError";
-  return err;
-}
-
-describe("CardKit request timeout", () => {
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-  });
-
-  it("aborts a hung card update so display.cardBusy can be released", async () => {
-    vi.useFakeTimers();
-    vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
-      new Promise<Response>((_resolve, reject) => {
-        init?.signal?.addEventListener("abort", () => reject(abortError()));
-      })
-    ));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const update = expect(updateCardKitCard("token", "card-1", "{}", 7))
-      .rejects.toThrow("updateCard cardId=card-1 seq=7 timeout after 15000ms");
-    await vi.advanceTimersByTimeAsync(15_000);
-
-    await update;
-    expect(fetchMock).toHaveBeenCalledWith(
-      expect.stringContaining("/cardkit/v1/cards/card-1"),
-      expect.objectContaining({ signal: expect.any(AbortSignal) }),
-    );
-  });
-
-  it("also aborts when response body reading hangs", async () => {
-    vi.useFakeTimers();
-    vi.spyOn(console, "error").mockImplementation(() => {});
-
-    const fetchMock = vi.fn((_url: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => (
-      Promise.resolve({
-        status: 200,
-        text: () => new Promise<string>((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => reject(abortError()));
-        }),
-      } as Response)
-    ));
-    vi.stubGlobal("fetch", fetchMock);
-
-    const update = expect(updateCardKitCard("token", "card-2", "{}", 8))
-      .rejects.toThrow("updateCard cardId=card-2 seq=8 timeout after 15000ms");
-    await vi.advanceTimersByTimeAsync(15_000);
-
-    await update;
-  });
-});