chatccc 0.2.227 → 0.2.229

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

@@ -1,275 +1,240 @@
-import { createHash } from "node:crypto";
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import {
-  applyPatchForTool,
-  createFileForTool,
-  deleteFileForTool,
-  editFileForTool,
-  listDirForTool,
-  moveFileForTool,
-  readFileForTool,
-  runCommandForTool,
-  searchCodeForTool,
-} from "../builtin/file-tools.ts";
-
-const tempDirs: string[] = [];
-
-async function makeTempDir(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-tools-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function sha256(text: string): string {
-  return createHash("sha256").update(text).digest("hex");
-}
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-
-describe("builtin file tools", () => {
-  it("reads a text file with line ranges", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, ".secret.txt"), "one\ntwo\nthree\n", "utf8");
-
-    const result = await readFileForTool(dir, { path: ".secret.txt", startLine: 2, endLine: 3 });
-
-    expect(result).toEqual(expect.objectContaining({
-      sha256: sha256("one\ntwo\nthree\n"),
-      isBinary: false,
-      content: "two\nthree",
-      startLine: 2,
-      endLine: 3,
-      totalLines: 4,
-    }));
-    expect(result.path).toContain(".secret.txt");
-  });
-
-  it("lists directory entries including hidden files", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, ".env"), "TOKEN=x", "utf8");
-
-    const result = await listDirForTool(dir);
-
-    expect(result.entries).toContainEqual(expect.objectContaining({
-      name: ".env",
-      type: "file",
-    }));
-  });
-
-  it("searches with the project-bundled ripgrep even when rg is absent from PATH", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "a.ts"), "const marker = 1;\n", "utf8");
-    const originalPath = process.env.PATH;
-    process.env.PATH = "";
-
-    try {
-      const result = await searchCodeForTool(dir, { query: "marker", glob: "*.ts" });
-
-      expect(result.matches).toEqual([
-        expect.objectContaining({
-          line: 1,
-          column: 7,
-          text: "const marker = 1;",
-        }),
-      ]);
-    } finally {
-      process.env.PATH = originalPath;
-    }
-  });
-
-  it("falls back to Node search when no ripgrep executable can be used", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "a.ts"), "const marker = 1;\n", "utf8");
-    await mkdir(join(dir, "nested"));
-    await writeFile(join(dir, "nested", "b.md"), "xx marker = 2\n", "utf8");
-    await writeFile(join(dir, "ignored.txt"), "marker = 3\n", "utf8");
-    const originalPath = process.env.PATH;
-    process.env.PATH = "";
-
-    try {
-      const result = await searchCodeForTool(
-        dir,
-        { query: "marker\\s*=\\s*\\d", glob: "**/*.{ts,md}", maxResults: 10 },
-        undefined,
-        { ripgrepCommands: [join(dir, "missing-rg")] },
-      );
-
-      expect(result.matches).toEqual([
-        expect.objectContaining({ path: join(dir, "a.ts"), line: 1, column: 7 }),
-        expect.objectContaining({ path: join(dir, "nested", "b.md"), line: 1, column: 4 }),
-      ]);
-      expect(result.truncated).toBe(false);
-    } finally {
-      process.env.PATH = originalPath;
-    }
-  });
-
-  it("runs non-interactive shell commands in the requested cwd", async () => {
-    const dir = await makeTempDir();
-
-    const result = await runCommandForTool(dir, {
-      command: "node -e \"process.stdout.write(process.cwd())\"",
-      timeoutMs: 5_000,
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(result.timedOut).toBe(false);
-    expect(result.stdout.toLowerCase()).toBe(dir.toLowerCase());
-    expect(result.stderr).toBe("");
-  });
-
-  it("returns non-zero command exits without throwing", async () => {
-    const dir = await makeTempDir();
-
-    const result = await runCommandForTool(dir, {
-      command: "node -e \"process.stderr.write('failed'); process.exit(7)\"",
-      timeoutMs: 5_000,
-    });
-
-    expect(result.exitCode).toBe(7);
-    expect(result.stderr).toBe("failed");
-    expect(result.timedOut).toBe(false);
-  });
-
-  it("edits a file with exact replacements and a SHA-256 precondition", async () => {
-    const dir = await makeTempDir();
-    const file = join(dir, "edit.txt");
-    await writeFile(file, "alpha\nbeta\ngamma\n", "utf8");
-
-    const result = await editFileForTool(dir, {
-      path: "edit.txt",
-      expectedSha256: sha256("alpha\nbeta\ngamma\n"),
-      edits: [{ oldText: "beta", newText: "BETA" }],
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      changed: true,
-      editsApplied: 1,
-      beforeSha256: sha256("alpha\nbeta\ngamma\n"),
-      afterSha256: sha256("alpha\nBETA\ngamma\n"),
-    }));
-    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");
-
-    await expect(editFileForTool(dir, {
-      path: "edit.txt",
-      expectedSha256: sha256("stale\n"),
-      edits: [{ oldText: "current", newText: "next" }],
-    })).rejects.toThrow("SHA-256 mismatch");
-  });
-
-  it("creates and deletes files", async () => {
-    const dir = await makeTempDir();
-
-    const created = await createFileForTool(dir, {
-      path: "created.txt",
-      content: "created\n",
-    });
-    expect(created).toEqual(expect.objectContaining({
-      changed: true,
-      afterSha256: sha256("created\n"),
-    }));
-    await expect(readFile(join(dir, "created.txt"), "utf8")).resolves.toBe("created\n");
-
-    const deleted = await deleteFileForTool(dir, {
-      path: "created.txt",
-      expectedSha256: sha256("created\n"),
-    });
-    expect(deleted).toEqual(expect.objectContaining({
-      deleted: true,
-      beforeSha256: sha256("created\n"),
-    }));
-    await expect(stat(join(dir, "created.txt"))).rejects.toThrow();
-  });
-
-  it("moves files and creates the destination directory", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "old.txt"), "move me\n", "utf8");
-
-    const result = await moveFileForTool(dir, {
-      sourcePath: "old.txt",
-      destinationPath: "nested/new.txt",
-      expectedSourceSha256: sha256("move me\n"),
-    });
-
-    expect(result).toEqual(expect.objectContaining({
-      moved: true,
-      sourceSha256: sha256("move me\n"),
-    }));
-    await expect(stat(join(dir, "old.txt"))).rejects.toThrow();
-    await expect(readFile(join(dir, "nested", "new.txt"), "utf8")).resolves.toBe("move me\n");
-  });
-
-  it("applies a unified diff patch", async () => {
-    const dir = await makeTempDir();
-    await writeFile(join(dir, "patch.txt"), "one\ntwo\nthree\n", "utf8");
-
-    const result = await applyPatchForTool(dir, {
-      patch: [
-        "--- a/patch.txt",
-        "+++ b/patch.txt",
-        "@@ -1,4 +1,4 @@",
-        " one",
-        "-two",
-        "+TWO",
-        " three",
-        " ",
-        "",
-      ].join("\n"),
-      expectedSha256ByPath: {
-        "patch.txt": sha256("one\ntwo\nthree\n"),
-      },
-    });
-
-    expect(result.changedFiles).toEqual([
-      expect.objectContaining({
-        action: "edit",
-        beforeSha256: sha256("one\ntwo\nthree\n"),
-        afterSha256: sha256("one\nTWO\nthree\n"),
-      }),
-    ]);
-    await expect(readFile(join(dir, "patch.txt"), "utf8")).resolves.toBe("one\nTWO\nthree\n");
-  });
-});
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  applyPatchForTool,
+  createFileForTool,
+  deleteFileForTool,
+  editFileForTool,
+  expandHomePath,
+  listDirForTool,
+  moveFileForTool,
+  readFileForTool,
+  runCommandForTool,
+  searchCodeForTool,
+} from "../builtin/file-tools.ts";
+
+const execFileAsync = promisify(execFile);
+const tempDirs: string[] = [];
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "deepccc-tools-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("expandHomePath", () => {
+  it("expands ~ and ~/ (both separators) to the user home directory", () => {
+    const home = homedir();
+    expect(expandHomePath("~")).toBe(home);
+    expect(expandHomePath("~/x/y.txt")).toBe(join(home, "x", "y.txt"));
+    expect(expandHomePath("~\\x\\y.txt")).toBe(join(home, "x", "y.txt"));
+  });
+
+  it("leaves absolute paths and other inputs unchanged", () => {
+    expect(expandHomePath("C:/a/b")).toBe("C:/a/b");
+    expect(expandHomePath("~other/x")).toBe("~other/x");
+    expect(expandHomePath("")).toBe("");
+  });
+});
+
+async function hasRg(): Promise<boolean> {
+  try {
+    await execFileAsync("rg", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sha256(text: string): string {
+  return createHash("sha256").update(text).digest("hex");
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("DeepCCC file tools", () => {
+  it("reads a text file with line ranges", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, ".secret.txt"), "one\ntwo\nthree\n", "utf8");
+
+    const result = await readFileForTool(dir, { path: ".secret.txt", startLine: 2, endLine: 3 });
+
+    expect(result).toEqual(expect.objectContaining({
+      sha256: sha256("one\ntwo\nthree\n"),
+      isBinary: false,
+      content: "two\nthree",
+      startLine: 2,
+      endLine: 3,
+      totalLines: 4,
+    }));
+    expect(result.path).toContain(".secret.txt");
+  });
+
+  it("lists directory entries including hidden files", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, ".env"), "TOKEN=x", "utf8");
+
+    const result = await listDirForTool(dir);
+
+    expect(result.entries).toContainEqual(expect.objectContaining({
+      name: ".env",
+      type: "file",
+    }));
+  });
+
+  it("searches code with rg without using a shell", async () => {
+    if (!await hasRg()) return;
+
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "a.ts"), "const marker = 1;\n", "utf8");
+
+    const result = await searchCodeForTool(dir, { query: "marker", glob: "*.ts" });
+
+    expect(result.matches).toEqual([
+      expect.objectContaining({
+        line: 1,
+        text: "const marker = 1;",
+      }),
+    ]);
+  });
+
+  it("runs non-interactive shell commands in the requested cwd", async () => {
+    const dir = await makeTempDir();
+
+    const result = await runCommandForTool(dir, {
+      command: "node -e \"process.stdout.write(process.cwd())\"",
+      timeoutMs: 5_000,
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.timedOut).toBe(false);
+    expect(result.stdout.toLowerCase()).toBe(dir.toLowerCase());
+    expect(result.stderr).toBe("");
+  });
+
+  it("returns non-zero command exits without throwing", async () => {
+    const dir = await makeTempDir();
+
+    const result = await runCommandForTool(dir, {
+      command: "node -e \"process.stderr.write('failed'); process.exit(7)\"",
+      timeoutMs: 5_000,
+    });
+
+    expect(result.exitCode).toBe(7);
+    expect(result.stderr).toBe("failed");
+    expect(result.timedOut).toBe(false);
+  });
+
+  it("edits a file with exact replacements and a SHA-256 precondition", async () => {
+    const dir = await makeTempDir();
+    const file = join(dir, "edit.txt");
+    await writeFile(file, "alpha\nbeta\ngamma\n", "utf8");
+
+    const result = await editFileForTool(dir, {
+      path: "edit.txt",
+      expectedSha256: sha256("alpha\nbeta\ngamma\n"),
+      edits: [{ oldText: "beta", newText: "BETA" }],
+    });
+
+    expect(result).toEqual(expect.objectContaining({
+      changed: true,
+      editsApplied: 1,
+      beforeSha256: sha256("alpha\nbeta\ngamma\n"),
+      afterSha256: sha256("alpha\nBETA\ngamma\n"),
+    }));
+    await expect(readFile(file, "utf8")).resolves.toBe("alpha\nBETA\ngamma\n");
+  });
+
+  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");
+
+    await expect(editFileForTool(dir, {
+      path: "edit.txt",
+      expectedSha256: sha256("stale\n"),
+      edits: [{ oldText: "current", newText: "next" }],
+    })).rejects.toThrow("SHA-256 mismatch");
+  });
+
+  it("creates and deletes files", async () => {
+    const dir = await makeTempDir();
+
+    const created = await createFileForTool(dir, {
+      path: "created.txt",
+      content: "created\n",
+    });
+    expect(created).toEqual(expect.objectContaining({
+      changed: true,
+      afterSha256: sha256("created\n"),
+    }));
+    await expect(readFile(join(dir, "created.txt"), "utf8")).resolves.toBe("created\n");
+
+    const deleted = await deleteFileForTool(dir, {
+      path: "created.txt",
+      expectedSha256: sha256("created\n"),
+    });
+    expect(deleted).toEqual(expect.objectContaining({
+      deleted: true,
+      beforeSha256: sha256("created\n"),
+    }));
+    await expect(stat(join(dir, "created.txt"))).rejects.toThrow();
+  });
+
+  it("moves files and creates the destination directory", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "old.txt"), "move me\n", "utf8");
+
+    const result = await moveFileForTool(dir, {
+      sourcePath: "old.txt",
+      destinationPath: "nested/new.txt",
+      expectedSourceSha256: sha256("move me\n"),
+    });
+
+    expect(result).toEqual(expect.objectContaining({
+      moved: true,
+      sourceSha256: sha256("move me\n"),
+    }));
+    await expect(stat(join(dir, "old.txt"))).rejects.toThrow();
+    await expect(readFile(join(dir, "nested", "new.txt"), "utf8")).resolves.toBe("move me\n");
+  });
+
+  it("applies a unified diff patch", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "patch.txt"), "one\ntwo\nthree\n", "utf8");
+
+    const result = await applyPatchForTool(dir, {
+      patch: [
+        "--- a/patch.txt",
+        "+++ b/patch.txt",
+        "@@ -1,4 +1,4 @@",
+        " one",
+        "-two",
+        "+TWO",
+        " three",
+        " ",
+        "",
+      ].join("\n"),
+      expectedSha256ByPath: {
+        "patch.txt": sha256("one\ntwo\nthree\n"),
+      },
+    });
+
+    expect(result.changedFiles).toEqual([
+      expect.objectContaining({
+        action: "edit",
+        beforeSha256: sha256("one\ntwo\nthree\n"),
+        afterSha256: sha256("one\nTWO\nthree\n"),
+      }),
+    ]);
+    await expect(readFile(join(dir, "patch.txt"), "utf8")).resolves.toBe("one\nTWO\nthree\n");
+  });
+});

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

@@ -1,9 +1,10 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { mkdtempSync, rmSync, writeFileSync, mkdirSync, utimesSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 
 import {
+  normalizeSkillPathForPrompt,
   parseSkillFrontmatter,
   scanSkillsDirs,
   buildDefaultSkillDirs,
@@ -47,14 +48,14 @@ describe("parseSkillFrontmatter", () => {
     const content = [
       "---",
       "name: feishu-doc-download-md",
-      "description: 涓嬭浇椋炰功鏂囨。涓?Markdown",
+      "description: 下载飞书文档为 Markdown",
       "---",
       "",
-      "# 姝ｆ枃",
+      "# 正文",
     ].join("\n");
     expect(parseSkillFrontmatter(content)).toEqual({
       name: "feishu-doc-download-md",
-      description: "涓嬭浇椋炰功鏂囨。涓?Markdown",
+      description: "下载飞书文档为 Markdown",
     });
   });
 
@@ -70,10 +71,10 @@ describe("parseSkillFrontmatter", () => {
   });
 
   it("handles CRLF line endings", () => {
-    const content = "---\r\nname: crlf-skill\r\ndescription: CRLF 鎻忚堪\r\n---\r\n\r\nbody";
+    const content = "---\r\nname: crlf-skill\r\ndescription: CRLF 描述\r\n---\r\n\r\nbody";
     expect(parseSkillFrontmatter(content)).toEqual({
       name: "crlf-skill",
-      description: "CRLF 鎻忚堪",
+      description: "CRLF 描述",
     });
   });
 });
@@ -158,7 +159,7 @@ describe("scanSkillsDirs hot reload (mtime cache)", () => {
     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 鍓嶈繘
+    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");
@@ -171,7 +172,7 @@ describe("scanSkillsDirs hot reload (mtime cache)", () => {
     const first = await scanSkillsDirs([spec(dir, "deepccc")]);
     expect(first).toHaveLength(1);
 
-    makeSkill(dir, "b", "B"); // 鏂版妧鑳斤紝鏃犻渶鏀?mtime锛堢洰褰曟灇涓炬瘡娆￠兘鍋氾級
+    makeSkill(dir, "b", "B"); // 新技能，无需改 mtime（目录枚举每次都做）
     const second = await scanSkillsDirs([spec(dir, "deepccc")]);
     expect(second.map((s) => s.name).sort()).toEqual(["a", "b"]);
   });
@@ -211,12 +212,27 @@ describe("buildDefaultSkillDirs", () => {
   });
 });
 
+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: "涓嬭浇椋炰功鏂囨。",
+        description: "下载飞书文档",
         skillPath: "C:/x/feishu-doc/SKILL.md",
         source: "codex",
         scope: "global",
@@ -231,6 +247,22 @@ describe("buildSkillsIndexPrompt", () => {
     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("");
   });